// src/ui/handlers/ui.rs

use crate::tui::terminal::TerminalCore;
use crate::services::grpc_client::GrpcClient;
use crate::services::auth::AuthClient;
use crate::services::ui_service::UiService;  // Add this import
use crate::tui::terminal::EventReader;
use crate::tui::functions::common::CommandHandler;
use crate::config::colors::themes::Theme;
use crate::config::binds::config::Config;
use crate::ui::handlers::render::render_ui;
use crate::state::pages::form::FormState;
use crate::state::pages::auth::AuthState;
use crate::modes::handlers::event::EventHandler;
use crate::state::state::AppState;

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

    // Initialize app_state first
    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?;

    // Initialize FormState with dynamic fields
    let mut form_state = FormState::new(column_names);

    // The rest of your UI initialization remains the same
    let mut event_handler = EventHandler::new().await?;
    let event_reader = EventReader::new();

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

    loop {
        UiService::update_adresar_count(&mut grpc_client, &mut app_state).await?;

        terminal.draw(|f| {
            render_ui(
                f,
                &mut form_state,
                &mut auth_state,
                &theme,
                event_handler.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,
            );
        })?;

        let total_count = app_state.total_count;
        let mut current_position = app_state.current_position;

        let event = event_reader.read_event()?;
        let (should_exit, message) = event_handler.handle_event(
            event,
            &config,
            &mut terminal,
            &mut grpc_client,
            &mut command_handler,
            &mut form_state,
            &mut app_state,
            total_count,
            &mut current_position,
        ).await?;

        app_state.current_position = current_position;

        // Handle position changes and update form state
        if !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 > total_count + 1 {
                app_state.current_position = total_count + 1;
            }
            if app_state.current_position > 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 <= total_count {
                // Existing entry - load data
                let current_position = app_state.current_position;
                let message = UiService::load_adresar_by_position(
                    &mut grpc_client,
                    &mut app_state,
                    &mut form_state,
                    current_position
                ).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);
                event_handler.command_message = message;
            } else {
                // Invalid position - reset to first entry
                app_state.current_position = 1;
            }
        }

        event_handler.command_message = message;
        if should_exit {
            return Ok(());
        }
    }
}