// src/modes/canvas/edit.rs

use crate::config::binds::config::Config;
use crate::services::grpc_client::GrpcClient;
use crate::state::pages::{auth::{AuthState, RegisterState}};
use crate::state::canvas_state::CanvasState;
use crate::state::pages::form::FormState;
use crate::functions::modes::edit::{auth_e, form_e};
use crate::modes::handlers::event::EventOutcome;
use crate::state::state::AppState;
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};

pub async fn handle_edit_event(
    key: KeyEvent,
    config: &Config,
    form_state: &mut FormState,
    auth_state: &mut AuthState,
    register_state: &mut RegisterState,
    ideal_cursor_column: &mut usize,
    command_message: &mut String,
    current_position: &mut u64,
    total_count: u64,
    grpc_client: &mut GrpcClient,
    app_state: &AppState,
) -> Result<String, Box<dyn std::error::Error>> {

    // Global command mode check
    if let Some("enter_command_mode") = config.get_action_for_key_in_mode(
        &config.keybindings.global,
        key.code,
        key.modifiers
    ) {
        *command_message = "Switching to Command Mode...".to_string();
        return Ok(command_message.clone());
    }

    // Common actions (save/revert)
    if let Some(action) = config.get_action_for_key_in_mode(
        &config.keybindings.common,
        key.code,
        key.modifiers
    ) {
        if matches!(action, "save" | "revert") {
            let message = if app_state.ui.show_login {
                auth_e::execute_common_action(
                    action,
                    auth_state,  // Concrete AuthState
                    grpc_client,
                    current_position,
                    total_count
                ).await
            } else if app_state.ui.show_register {
                auth_e::execute_common_action(
                    action,
                    register_state,
                    grpc_client,
                    current_position,
                    total_count
                ).await
            } else {
                form_e::execute_common_action(
                    action,
                    form_state,  // Concrete FormState
                    grpc_client,
                    current_position,
                    total_count
                ).await
                .map(|outcome| match outcome {
                    EventOutcome::Ok(msg) => msg,
                    EventOutcome::Exit(msg) => format!("Exit requested: {}", msg),
                    EventOutcome::DataSaved(save_outcome, msg) => format!("Data saved ({:?}): {}", save_outcome, msg),
                    EventOutcome::ButtonSelected { context, index } => {
                        "Unexpected action in edit mode".to_string()
                    }
                })
            }?;
            return Ok(message);
        }
    }

    // Edit-specific actions
    if let Some(action) = config.get_edit_action_for_key(key.code, key.modifiers) {
        // --- Special Handling for Tab/Shift+Tab in Role Field ---
        if app_state.ui.show_register && register_state.current_field() == 4 {
            if !register_state.in_suggestion_mode && key.code == KeyCode::Tab && key.modifiers == KeyModifiers::NONE {
                register_state.update_role_suggestions();
                if !register_state.role_suggestions.is_empty() {
                    register_state.in_suggestion_mode = true;
                    register_state.selected_suggestion_index = Some(0); // Select first suggestion
                    return Ok("Suggestions shown".to_string());
                } else {
                    return Ok("No suggestions available".to_string());
                }
            }
        }
        // --- End Special Handling ---

        return if app_state.ui.show_login {
            auth_e::execute_edit_action(
                action,
                key,
                auth_state,
                ideal_cursor_column,
                grpc_client,
                current_position,
                total_count
            ).await
        } else if app_state.ui.show_register {
            auth_e::execute_edit_action(
                action,
                key,
                register_state,
                ideal_cursor_column,
                grpc_client,
                current_position,
                total_count
            ).await
        } else {
            form_e::execute_edit_action(
                action,
                key,
                form_state,
                ideal_cursor_column,
                grpc_client,
                current_position,
                total_count
            ).await
        };
    }

    // Character insertion
    if let KeyCode::Char(_) = key.code {
        // If in suggestion mode, exit it before inserting char
        if app_state.ui.show_register && register_state.in_suggestion_mode {
            register_state.in_suggestion_mode = false;
            register_state.show_role_suggestions = false;
            register_state.selected_suggestion_index = None;
        }
        let is_role_field = app_state.ui.show_register && register_state.current_field() == 4;
        // --- End Autocomplete Trigger ---
        
        return if app_state.ui.show_login {
            auth_e::execute_edit_action(
                "insert_char",
                key,
                auth_state,
                ideal_cursor_column,
                grpc_client,
                current_position,
                total_count
            ).await
        } else if app_state.ui.show_register {
            auth_e::execute_edit_action(
                "insert_char",
                key,
                register_state,
                ideal_cursor_column,
                grpc_client,
                current_position,
                total_count
            ).await
        } else {
            form_e::execute_edit_action(
                "insert_char",
                key,
                form_state,
                ideal_cursor_column,
                grpc_client,
                current_position,
                total_count
            ).await
        };
    }

    // Handle Backspace/Delete for Autocomplete Trigger
    if matches!(key.code, KeyCode::Backspace | KeyCode::Delete) {
        // If in suggestion mode, exit it before deleting char
        if app_state.ui.show_register && register_state.in_suggestion_mode {
            register_state.in_suggestion_mode = false;
            register_state.show_role_suggestions = false;
            register_state.selected_suggestion_index = None;
        }
        let is_role_field = app_state.ui.show_register && register_state.current_field() == 4;
        let action_str = if key.code == KeyCode::Backspace { "backspace" } else { "delete_char" };

        // Execute the action first
        let result = if app_state.ui.show_register {
             auth_e::execute_edit_action(
                action_str,
                key,
                register_state,
                ideal_cursor_column,
                grpc_client,
                current_position,
                total_count
            ).await
        } else {
            // Handle for login/form if needed, assuming auth_e covers RegisterState
             Ok("Action not applicable here".to_string()) // Placeholder
        }?;

        return Ok(result);
    }

    Ok(command_message.clone())
}