// src/ui/handlers/ui.rs

use crate::config::binds::config::Config;
use crate::config::colors::themes::Theme;
use crate::modes::common::commands::CommandHandler;
use crate::modes::handlers::event::{EventHandler, EventOutcome}; // Import EventOutcome
use crate::modes::handlers::mode_manager::{AppMode, ModeManager};
use crate::services::grpc_client::GrpcClient;
use crate::services::ui_service::UiService;
use crate::state::pages::canvas_state::CanvasState;
use crate::state::pages::form::FormState;
use crate::state::pages::auth::AuthState;
use crate::state::pages::auth::LoginState;
use crate::state::pages::auth::RegisterState;
use crate::state::pages::admin::AdminState;
use crate::state::pages::intro::IntroState;
use crate::state::app::state::AppState;
 // Import SaveOutcome
use crate::tui::terminal::{EventReader, TerminalCore};
use crate::ui::handlers::render::render_ui;
use crossterm::cursor::SetCursorStyle;

pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
    let config = Config::load()?;
    let theme = Theme::from_str(&config.colors.theme);
    let mut terminal = TerminalCore::new()?;
    let mut grpc_client = GrpcClient::new().await?;
    let mut command_handler = CommandHandler::new();

    let mut event_handler = EventHandler::new().await?;
    let event_reader = EventReader::new();

    let mut auth_state = AuthState::default();
    let mut login_state = LoginState::default();
    let mut register_state = RegisterState::default();
    let mut intro_state = IntroState::default();
    let mut admin_state = AdminState::default();
    let mut app_state = AppState::new()?;

    // Initialize app state with profile tree and table structure
    let column_names =
        UiService::initialize_app_state(&mut grpc_client, &mut app_state)
            .await?;
    let mut form_state = FormState::new(column_names);

    // Fetch the total count of Adresar entries
    UiService::initialize_adresar_count(&mut grpc_client, &mut app_state)
        .await?;
    form_state.reset_to_empty();

    loop {
        // Determine edit mode based on EventHandler state
        let is_edit_mode = event_handler.is_edit_mode;

        terminal.draw(|f| {
            render_ui(
                f,
                &mut form_state,
                &mut auth_state,
                &login_state,
                &register_state,
                &intro_state,
                &mut admin_state,
                &theme,
                is_edit_mode,
                app_state.total_count,
                app_state.current_position,
                &app_state.current_dir,
                &event_handler.command_input,
                event_handler.command_mode,
                &event_handler.command_message,
                &app_state,
            );
        })?;

        // --- Cursor Visibility Logic ---
        let current_mode = ModeManager::derive_mode(&app_state, &event_handler);
        match current_mode {
            AppMode::Edit => {
                terminal.show_cursor()?;
            }
            AppMode::ReadOnly => {
                if !app_state.ui.focus_outside_canvas {
                    terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
                } else {
                    terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?;
                }
                terminal.show_cursor()?;
            }
            AppMode::General => {
                if app_state.ui.focus_outside_canvas {
                    terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?;
                    terminal.show_cursor()?;
                } else {
                    terminal.hide_cursor()?;
                }
            }
            AppMode::Command => {
                terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?;
                terminal.show_cursor()?;
            }
        }
        // --- End Cursor Visibility Logic ---

        let total_count = app_state.total_count; // Keep track for save logic
        let mut current_position = app_state.current_position;
        let position_before_event = current_position;

        let event = event_reader.read_event()?;

        // Get the outcome from the event handler
        let event_outcome_result = event_handler
            .handle_event(
                event,
                &config,
                &mut terminal,
                &mut grpc_client,
                &mut command_handler,
                &mut form_state,
                &mut auth_state,
                &mut login_state,
                &mut register_state,
                &mut intro_state,
                &mut admin_state,
                &mut app_state,
                total_count,
                &mut current_position,
            )
            .await;

        // Update position based on handler's modification
        app_state.current_position = current_position;

        // --- Centralized Consequence Handling ---
        let mut should_exit = false;
        match event_outcome_result {
            // Handle the Result first
            Ok(outcome) => match outcome {
                // Handle the Ok variant containing EventOutcome
                EventOutcome::Ok(message) => {
                    if !message.is_empty() {
                        event_handler.command_message = message;
                    }
                }
                EventOutcome::Exit(message) => {
                    event_handler.command_message = message;
                    should_exit = true;
                }
                EventOutcome::DataSaved(save_outcome, message) => {
                    event_handler.command_message = message; // Show save status

                    // *** Delegate outcome handling to UiService ***
                    if let Err(e) = UiService::handle_save_outcome(
                        save_outcome,
                        &mut grpc_client,
                        &mut app_state,
                        &mut form_state,
                    )
                    .await
                    {
                        // Handle potential errors from the outcome handler itself
                        event_handler.command_message =
                            format!("Error handling save outcome: {}", e);
                    }
                    // No count update needed for UpdatedExisting or NoChange
                }
                EventOutcome::ButtonSelected { context, index } => {
                    event_handler.command_message = "Internal error: Unexpected button state".to_string();
                }
            },
            Err(e) => {
                // Handle errors from handle_event, e.g., log or display
                event_handler.command_message = format!("Error: {}", e);
                // Decide if the error is fatal, maybe set should_exit = true;
            }
        }

        // --- Position Change Handling (after outcome processing) ---
        let position_changed =
            app_state.current_position != position_before_event; // Calculate after potential update
                                                                 // Recalculate total_count *after* potential update
        let current_total_count = app_state.total_count;

        // Handle position changes and update form state (Only when form is shown)
        if app_state.ui.show_form {
            if position_changed && !event_handler.is_edit_mode {
                let current_input = form_state.get_current_input();
                let max_cursor_pos = if !current_input.is_empty() {
                    current_input.len() - 1 // Limit to last character in readonly mode
                } else {
                    0
                };
                form_state.current_cursor_pos =
                    event_handler.ideal_cursor_column.min(max_cursor_pos);

                // Ensure position never exceeds total_count + 1
                if app_state.current_position > current_total_count + 1 {
                    app_state.current_position = current_total_count + 1;
                }
                if app_state.current_position > current_total_count {
                    // New entry - reset form
                    form_state.reset_to_empty();
                    form_state.current_field = 0;
                } else if app_state.current_position >= 1
                    && app_state.current_position <= current_total_count
                {
                    // Existing entry - load data
                    let current_position_to_load = app_state.current_position; // Use a copy
                    let load_message = UiService::load_adresar_by_position(
                        &mut grpc_client,
                        &mut app_state, // Pass app_state mutably if needed by the service
                        &mut form_state,
                        current_position_to_load,
                    )
                    .await?;

                    let current_input = form_state.get_current_input();
                    let max_cursor_pos = if !event_handler.is_edit_mode
                        && !current_input.is_empty()
                    {
                        current_input.len() - 1 // In readonly mode, limit to last character
                    } else {
                        current_input.len()
                    };
                    form_state.current_cursor_pos = event_handler
                        .ideal_cursor_column
                        .min(max_cursor_pos);
                    // Don't overwrite message from handle_event if load_message is simple success
                    if !load_message.starts_with("Loaded entry")
                        || event_handler.command_message.is_empty()
                    {
                        event_handler.command_message = load_message;
                    }
                } else {
                    // Invalid position (e.g., 0) - reset to first entry or new entry mode
                    app_state.current_position =
                        1.min(current_total_count + 1); // Go to 1 or new entry if empty
                    if app_state.current_position > total_count {
                        form_state.reset_to_empty();
                        form_state.current_field = 0;
                    }
                }
            } else if !position_changed && !event_handler.is_edit_mode {
                // If position didn't change but we are in read-only, just adjust cursor
                let current_input = form_state.get_current_input();
                let max_cursor_pos = if !current_input.is_empty() {
                    current_input.len() - 1
                } else {
                    0
                };
                form_state.current_cursor_pos =
                    event_handler.ideal_cursor_column.min(max_cursor_pos);
            }
        } else if app_state.ui.show_register {
            if !event_handler.is_edit_mode {
                let current_input = register_state.get_current_input();
                let max_cursor_pos = if !current_input.is_empty() {
                    current_input.len() - 1
                } else {
                    0
                };
                register_state.current_cursor_pos = event_handler.ideal_cursor_column.min(max_cursor_pos);
            }
        } else if app_state.ui.show_login {
            if !event_handler.is_edit_mode {
                let current_input = login_state.get_current_input();
                let max_cursor_pos = if !current_input.is_empty() {
                    current_input.len() - 1
                } else {
                    0
                };
                login_state.current_cursor_pos = event_handler.ideal_cursor_column.min(max_cursor_pos);
            }
        }

        // Check exit condition *after* processing outcome
        if should_exit {
            // terminal.cleanup()?; // Optional: Drop handles this
            return Ok(());
        }
    }
}