limit_cli/tui/app/

app_impl.rs

//! TUI Application module
//!
//! Contains the main TUI application loop (`TuiApp`)

use crate::clipboard::ClipboardManager;
use crate::error::CliError;
use crate::tui::autocomplete::FileAutocompleteManager;
use crate::tui::bridge::TuiBridge;
use crate::tui::input::{InputEditor, InputHandler};
use crate::tui::ui::UiRenderer;
use crate::tui::TuiState;
use crossterm::event::{
    self, DisableBracketedPaste, DisableMouseCapture, EnableBracketedPaste, EnableMouseCapture,
    Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers, MouseButton, MouseEventKind,
};
use crossterm::execute;
use crossterm::terminal::{EnterAlternateScreen, LeaveAlternateScreen};
use limit_tui::components::Message;
use ratatui::{backend::CrosstermBackend, Terminal};
use std::io;
use std::time::{Duration, Instant};

pub struct TuiApp {
    tui_bridge: TuiBridge,
    terminal: Terminal<CrosstermBackend<io::Stdout>>,
    running: bool,
    /// Input text editor
    input_editor: InputEditor,
    /// History file path
    history_path: std::path::PathBuf,
    status_message: String,
    status_is_error: bool,
    /// Mouse selection state
    mouse_selection_start: Option<(u16, u16)>,
    /// Clipboard manager
    clipboard: Option<ClipboardManager>,
    /// File autocomplete manager
    autocomplete_manager: FileAutocompleteManager,
    /// Cancellation token for current LLM operation
    cancellation_token: Option<tokio_util::sync::CancellationToken>,
    /// Input handler for keyboard/mouse events
    input_handler: InputHandler,
    /// Command registry for handling /commands
    command_registry: crate::tui::commands::CommandRegistry,
}

impl TuiApp {
    /// Create a new TUI application
    pub fn new(tui_bridge: TuiBridge) -> Result<Self, CliError> {
        let backend = CrosstermBackend::new(io::stdout());
        let terminal =
            Terminal::new(backend).map_err(|e| CliError::IoError(io::Error::other(e)))?;

        let session_id = tui_bridge.session_id();
        tracing::info!("TUI started with session: {}", session_id);

        // Initialize history path (~/.limit/input_history.bin)
        let home_dir = dirs::home_dir()
            .ok_or_else(|| CliError::ConfigError("Failed to get home directory".to_string()))?;
        let limit_dir = home_dir.join(".limit");
        let history_path = limit_dir.join("input_history.bin");

        // Load input editor with history
        let input_editor = InputEditor::with_history(&history_path)
            .map_err(|e| CliError::ConfigError(format!("Failed to load input history: {}", e)))?;

        let clipboard = match ClipboardManager::new() {
            Ok(cb) => {
                tracing::debug!("✓ Clipboard initialized successfully");
                tracing::info!("Clipboard initialized successfully");
                Some(cb)
            }
            Err(e) => {
                tracing::debug!("✗ Clipboard initialization failed: {}", e);
                tracing::warn!("Clipboard unavailable: {}", e);
                None
            }
        };

        // Initialize autocomplete manager with current directory
        let working_dir = std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from("."));
        let autocomplete_manager = FileAutocompleteManager::new(working_dir);

        // Initialize command registry
        let command_registry = crate::tui::commands::create_default_registry();

        Ok(Self {
            tui_bridge,
            terminal,
            running: true,
            input_editor,
            history_path,
            status_message: "Ready - Type a message and press Enter".to_string(),
            status_is_error: false,
            mouse_selection_start: None,
            clipboard,
            autocomplete_manager,
            cancellation_token: None,
            input_handler: InputHandler::new(),
            command_registry,
        })
    }

    /// Run the TUI event loop
    pub fn run(&mut self) -> Result<(), CliError> {
        // Enter alternate screen - creates a clean buffer for TUI
        execute!(std::io::stdout(), EnterAlternateScreen)
            .map_err(|e| CliError::IoError(io::Error::other(e)))?;

        // Enable mouse capture for scroll support
        execute!(std::io::stdout(), EnableMouseCapture)
            .map_err(|e| CliError::IoError(io::Error::other(e)))?;

        // Enable bracketed paste for multi-line paste support
        execute!(std::io::stdout(), EnableBracketedPaste)
            .map_err(|e| CliError::IoError(io::Error::other(e)))?;

        crossterm::terminal::enable_raw_mode()
            .map_err(|e| CliError::IoError(io::Error::other(e)))?;

        // Guard to ensure cleanup on panic
        struct AlternateScreenGuard;
        impl Drop for AlternateScreenGuard {
            fn drop(&mut self) {
                let _ = crossterm::terminal::disable_raw_mode();
                let _ = execute!(std::io::stdout(), DisableBracketedPaste);
                let _ = execute!(std::io::stdout(), DisableMouseCapture);
                let _ = execute!(std::io::stdout(), LeaveAlternateScreen);
            }
        }
        let _guard = AlternateScreenGuard;

        self.run_inner()
    }

    fn run_inner(&mut self) -> Result<(), CliError> {
        while self.running {
            // Process events from the agent
            self.tui_bridge.process_events()?;

            // Update spinner if in thinking state
            if matches!(self.tui_bridge.state(), TuiState::Thinking) {
                self.tui_bridge.tick_spinner();
            }

            // Update status based on state
            self.update_status();

            // Handle user input with poll timeout
            if event::poll(Duration::from_millis(100))
                .map_err(|e| CliError::IoError(io::Error::other(e)))?
            {
                match event::read().map_err(|e| CliError::IoError(io::Error::other(e)))? {
                    Event::Key(key) => {
                        // Log ALL key events (not just Press) to debug modifier detection
                        tracing::debug!(
                            "Event::Key - code={:?} mod={:?} kind={:?}",
                            key.code,
                            key.modifiers,
                            key.kind
                        );

                        if key.kind == KeyEventKind::Press {
                            self.handle_key_event(key)?;
                        }
                    }
                    Event::Mouse(mouse) => {
                        match mouse.kind {
                            MouseEventKind::Down(MouseButton::Left) => {
                                tracing::debug!("MouseDown at ({}, {})", mouse.column, mouse.row);
                                self.mouse_selection_start = Some((mouse.column, mouse.row));
                                // Map screen position to message/offset and start selection
                                let chat = self.tui_bridge.chat_view().lock().unwrap();
                                tracing::debug!(
                                    "  render_positions count: {}",
                                    chat.render_position_count()
                                );
                                if let Some((msg_idx, char_offset)) =
                                    chat.screen_to_text_pos(mouse.column, mouse.row)
                                {
                                    tracing::debug!(
                                        "  -> Starting selection at msg={}, offset={}",
                                        msg_idx,
                                        char_offset
                                    );
                                    drop(chat);
                                    self.tui_bridge
                                        .chat_view()
                                        .lock()
                                        .unwrap()
                                        .start_selection(msg_idx, char_offset);
                                } else {
                                    tracing::debug!("  -> No match, clearing selection");
                                    drop(chat);
                                    self.tui_bridge
                                        .chat_view()
                                        .lock()
                                        .unwrap()
                                        .clear_selection();
                                }
                            }
                            MouseEventKind::Drag(MouseButton::Left) => {
                                if self.mouse_selection_start.is_some() {
                                    // Extend selection to current position
                                    let chat = self.tui_bridge.chat_view().lock().unwrap();
                                    if let Some((msg_idx, char_offset)) =
                                        chat.screen_to_text_pos(mouse.column, mouse.row)
                                    {
                                        drop(chat);
                                        self.tui_bridge
                                            .chat_view()
                                            .lock()
                                            .unwrap()
                                            .extend_selection(msg_idx, char_offset);
                                    }
                                }
                            }
                            MouseEventKind::Up(MouseButton::Left) => {
                                self.mouse_selection_start = None;
                            }
                            MouseEventKind::ScrollUp => {
                                let mut chat = self.tui_bridge.chat_view().lock().unwrap();
                                chat.scroll_up();
                            }
                            MouseEventKind::ScrollDown => {
                                let mut chat = self.tui_bridge.chat_view().lock().unwrap();
                                chat.scroll_down();
                            }
                            _ => {}
                        }
                    }
                    Event::Paste(pasted) => {
                        if !self.tui_bridge.is_busy() {
                            self.insert_paste(&pasted);
                        }
                    }
                    _ => {}
                }
            } else {
                // No key event - tick cursor blink
                self.tick_cursor_blink();
            }

            // Draw the TUI
            self.draw()?;
        }

        // Save session before exiting
        if let Err(e) = self.tui_bridge.save_session() {
            tracing::error!("Failed to save session: {}", e);
        }

        // Save input history before exiting
        if let Err(e) = self.input_editor.save_history(&self.history_path) {
            tracing::error!("Failed to save input history: {}", e);
        }

        Ok(())
    }

    fn update_status(&mut self) {
        let session_id = self.tui_bridge.session_id();
        let has_activity = self
            .tui_bridge
            .activity_feed()
            .lock()
            .unwrap()
            .has_in_progress();

        match self.tui_bridge.state() {
            TuiState::Idle => {
                if has_activity {
                    // Show spinner when there are in-progress activities
                    let spinner = self.tui_bridge.spinner().lock().unwrap();
                    self.status_message = format!("{} Processing...", spinner.current_frame());
                } else {
                    self.status_message = format!(
                        "Ready | Session: {}",
                        session_id.chars().take(8).collect::<String>()
                    );
                }
                self.status_is_error = false;
            }
            TuiState::Thinking => {
                let spinner = self.tui_bridge.spinner().lock().unwrap();
                self.status_message = format!("{} Thinking...", spinner.current_frame());
                self.status_is_error = false;
            }
        }
    }

    /// Insert pasted text at cursor position without submitting
    fn insert_paste(&mut self, text: &str) {
        let truncated = self.input_editor.insert_paste(text);
        if truncated {
            self.status_message = "Paste truncated (too large)".to_string();
            self.status_is_error = true;
        }
    }

    /// Check if the current key event is a copy/paste shortcut
    /// Returns true for Ctrl+C/V on Linux/Windows, Cmd+C/V on macOS
    /// Note: Some macOS terminals report Cmd as CONTROL instead of SUPER
    fn is_copy_paste_modifier(&self, key: &KeyEvent, char: char) -> bool {
        #[cfg(target_os = "macos")]
        {
            // Accept both SUPER and CONTROL on macOS since terminal emulators vary
            let has_super = key.modifiers.contains(KeyModifiers::SUPER);
            let has_ctrl = key.modifiers.contains(KeyModifiers::CONTROL);
            let result = key.code == KeyCode::Char(char) && (has_super || has_ctrl);
            tracing::debug!("is_copy_paste_modifier('{}') macOS: code={:?}, mod={:?}, super={}, ctrl={}, result={}", 
                char, key.code, key.modifiers, has_super, has_ctrl, result);
            result
        }
        #[cfg(not(target_os = "macos"))]
        {
            let result =
                key.code == KeyCode::Char(char) && key.modifiers.contains(KeyModifiers::CONTROL);
            tracing::debug!(
                "is_copy_paste_modifier('{}') non-macOS: code={:?}, mod={:?}, ctrl={:?}, result={}",
                char,
                key.code,
                key.modifiers,
                KeyModifiers::CONTROL,
                result
            );
            result
        }
    }

    fn tick_cursor_blink(&mut self) {
        // Delegate to InputHandler
        self.input_handler.tick_cursor_blink();
    }

    fn handle_key_event(&mut self, key: KeyEvent) -> Result<(), CliError> {
        // Direct file logging (always works)
        tracing::debug!(
            "handle_key_event: code={:?} mod={:?} kind={:?}",
            key.code,
            key.modifiers,
            key.kind
        );

        // Special log for 'c' and 'v' keys to debug copy/paste
        if matches!(key.code, KeyCode::Char('c') | KeyCode::Char('v')) {
            tracing::debug!(
                ">>> SPECIAL: '{}' key detected with modifiers: {:?} (SUPER={:?}, CONTROL={:?})",
                if matches!(key.code, KeyCode::Char('c')) {
                    'c'
                } else {
                    'v'
                },
                key.modifiers,
                key.modifiers.contains(KeyModifiers::SUPER),
                key.modifiers.contains(KeyModifiers::CONTROL)
            );
        }

        // Copy selection to clipboard (Ctrl/Cmd+C)
        if self.is_copy_paste_modifier(&key, 'c') {
            tracing::debug!("✓ Copy shortcut CONFIRMED - processing...");
            let mut chat = self.tui_bridge.chat_view().lock().unwrap();
            let has_selection = chat.has_selection();
            tracing::debug!("has_selection={}", has_selection);

            if has_selection {
                if let Some(selected) = chat.get_selected_text() {
                    tracing::debug!("Selected text length={}", selected.len());
                    if !selected.is_empty() {
                        if let Some(ref clipboard) = self.clipboard {
                            tracing::debug!("Attempting to copy to clipboard...");
                            match clipboard.set_text(&selected) {
                                Ok(()) => {
                                    tracing::debug!("✓ Clipboard copy successful");
                                    self.status_message = "Copied to clipboard".to_string();
                                    self.status_is_error = false;
                                }
                                Err(e) => {
                                    tracing::debug!("✗ Clipboard copy failed: {}", e);
                                    self.status_message = format!("Clipboard error: {}", e);
                                    self.status_is_error = true;
                                }
                            }
                        } else {
                            tracing::debug!("✗ Clipboard not available (None)");
                            self.status_message = "Clipboard not available".to_string();
                            self.status_is_error = true;
                        }
                    } else {
                        tracing::debug!("Selected text is empty");
                    }
                    chat.clear_selection();
                } else {
                    tracing::debug!("get_selected_text() returned None");
                }
                return Ok(());
            }

            // No selection - do nothing (Ctrl+C is only for copying text)
            tracing::debug!("Ctrl/Cmd+C with no selection - ignoring");
            return Ok(());
        }

        // Paste from clipboard (Ctrl/Cmd+V)
        if self.is_copy_paste_modifier(&key, 'v') && !self.tui_bridge.is_busy() {
            tracing::debug!("✓ Paste shortcut CONFIRMED - processing...");
            if let Some(ref clipboard) = self.clipboard {
                tracing::debug!("Attempting to read from clipboard...");
                match clipboard.get_text() {
                    Ok(text) if !text.is_empty() => {
                        tracing::debug!("Read {} chars from clipboard", text.len());
                        self.insert_paste(&text);
                    }
                    Ok(_) => {
                        tracing::debug!("Clipboard is empty");
                    } // Empty clipboard
                    Err(e) => {
                        tracing::debug!("✗ Failed to read clipboard: {}", e);
                        self.status_message = format!("Could not read clipboard: {}", e);
                        self.status_is_error = true;
                    }
                }
            } else {
                tracing::debug!("✗ Clipboard not available (None)");
                self.status_message = "Clipboard not available".to_string();
                self.status_is_error = true;
            }
            return Ok(());
        }

        // Handle autocomplete navigation FIRST (before general scrolling)
        let autocomplete_active = self.autocomplete_manager.is_active();
        tracing::debug!(
            "Key handling: autocomplete_active={}, is_busy={}, history_len={}",
            autocomplete_active,
            self.tui_bridge.is_busy(),
            self.input_editor.history().len()
        );

        if autocomplete_active {
            match key.code {
                KeyCode::Up => {
                    self.autocomplete_manager.navigate_up();
                    return Ok(());
                }
                KeyCode::Down => {
                    self.autocomplete_manager.navigate_down();
                    return Ok(());
                }
                KeyCode::Enter | KeyCode::Tab => {
                    self.accept_file_completion();
                    return Ok(());
                }
                KeyCode::Esc => {
                    self.autocomplete_manager.deactivate();
                    return Ok(());
                }
                _ => {}
            }
        }

        // Handle ESC for cancellation (must be before is_busy check)
        if key.code == KeyCode::Esc {
            // If autocomplete is active, cancel it
            if self.autocomplete_manager.is_active() {
                self.autocomplete_manager.deactivate();
            } else if self.tui_bridge.is_busy() {
                // Double-ESC to cancel current operation
                let now = Instant::now();
                let last_esc_time = self.input_handler.last_esc_time();
                let should_cancel = if let Some(last_esc) = last_esc_time {
                    now.duration_since(last_esc) < Duration::from_millis(1000)
                } else {
                    false
                };

                if should_cancel {
                    self.cancel_current_operation();
                } else {
                    // First ESC - show feedback
                    self.status_message = "Press ESC again to cancel".to_string();
                    self.status_is_error = false;
                    self.input_handler.set_last_esc_time(now);
                }
            } else {
                tracing::debug!("Esc pressed, exiting");
                self.running = false;
            }
            return Ok(());
        }

        // Allow scrolling even when agent is busy (PageUp/PageDown only)
        // Calculate actual viewport height dynamically
        let term_height = self.terminal.size().map(|s| s.height).unwrap_or(24);
        let viewport_height = term_height
            .saturating_sub(1) // status bar - input area (6 lines) - borders (~2)
            .saturating_sub(7); // status (1) + input (6) + top/bottom borders (2) = 9
        match key.code {
            KeyCode::PageUp => {
                let mut chat = self.tui_bridge.chat_view().lock().unwrap();
                chat.scroll_page_up(viewport_height);
                return Ok(());
            }
            KeyCode::PageDown => {
                let mut chat = self.tui_bridge.chat_view().lock().unwrap();
                chat.scroll_page_down(viewport_height);
                return Ok(());
            }
            KeyCode::Up => {
                // Use for history navigation
                tracing::debug!(
                    "Up arrow: navigating history up, history_len={}",
                    self.input_editor.history().len()
                );
                let navigated = self.input_editor.navigate_history_up();
                tracing::debug!(
                    "Up arrow: navigated={}, text='{}'",
                    navigated,
                    self.input_editor.text()
                );
                return Ok(());
            }
            KeyCode::Down => {
                // Use for history navigation
                tracing::debug!(
                    "Down arrow: navigating history down, is_navigating={}",
                    self.input_editor.is_navigating_history()
                );
                let navigated = self.input_editor.navigate_history_down();
                tracing::debug!(
                    "Down arrow: navigated={}, text='{}'",
                    navigated,
                    self.input_editor.text()
                );
                return Ok(());
            }
            _ => {}
        }

        // Don't accept input while agent is busy
        if self.tui_bridge.is_busy() {
            tracing::debug!("Agent busy, ignoring");
            return Ok(());
        }

        // Handle backspace - try multiple detection methods
        if self.handle_backspace(&key) {
            tracing::debug!("Backspace handled, input: {:?}", self.input_editor.text());
            return Ok(());
        }

        match key.code {
            KeyCode::Delete => {
                if self.input_editor.delete_char_at() {
                    tracing::debug!("Delete: input now: {:?}", self.input_editor.text());
                }
            }
            KeyCode::Left => {
                tracing::debug!(
                    "KeyCode::Left: has_pasted_content={}",
                    self.input_editor.has_pasted_content()
                );
                self.input_editor.move_left();
            }
            KeyCode::Right => {
                tracing::debug!(
                    "KeyCode::Right: has_pasted_content={}",
                    self.input_editor.has_pasted_content()
                );
                self.input_editor.move_right();
            }
            KeyCode::Home => {
                self.input_editor.move_to_start();
            }
            KeyCode::End => {
                self.input_editor.move_to_end();
            }
            KeyCode::Enter => {
                // If autocomplete is active, it's already handled above
                self.handle_enter()?;
            }
            // Regular character input (including UTF-8)
            KeyCode::Char(c)
                if key.modifiers == KeyModifiers::NONE || key.modifiers == KeyModifiers::SHIFT =>
            {
                // Check if we're triggering autocomplete with @
                if c == '@' {
                    // Insert @ character
                    self.input_editor.insert_char('@');

                    // Activate autocomplete
                    self.activate_file_autocomplete();
                } else if self.autocomplete_manager.is_active() {
                    // Update autocomplete and insert character
                    self.autocomplete_manager.append_char(c);
                    self.input_editor.insert_char(c);
                } else {
                    // Normal character insertion
                    self.input_editor.insert_char(c);
                }
            }
            _ => {
                // Ignore other keys
            }
        }

        Ok(())
    }

    /// Handle backspace with multiple detection methods
    fn handle_backspace(&mut self, key: &KeyEvent) -> bool {
        // Method 1: Standard Backspace keycode
        if key.code == KeyCode::Backspace {
            tracing::debug!("Backspace detected via KeyCode::Backspace");
            self.delete_char_before_cursor();
            return true;
        }

        // Method 2: Ctrl+H (common backspace mapping)
        if key.code == KeyCode::Char('h') && key.modifiers == KeyModifiers::CONTROL {
            tracing::debug!("Backspace detected via Ctrl+H");
            self.delete_char_before_cursor();
            return true;
        }

        // Method 3: Check for DEL (127) or BS (8) characters
        if let KeyCode::Char(c) = key.code {
            if c == '\x7f' || c == '\x08' {
                tracing::debug!("Backspace detected via char code: {}", c as u8);
                self.delete_char_before_cursor();
                return true;
            }
        }

        false
    }

    fn delete_char_before_cursor(&mut self) {
        tracing::debug!(
            "delete_char: cursor={}, len={}, input={:?}",
            self.input_editor.cursor(),
            self.input_editor.text().len(),
            self.input_editor.text()
        );

        // If autocomplete is active, handle backspace specially
        if self.autocomplete_manager.is_active() {
            let should_close = self.autocomplete_manager.backspace();

            if should_close
                && self.input_editor.cursor() > 0
                && self.input_editor.char_before_cursor() == Some('@')
            {
                self.input_editor.delete_char_before();
                self.autocomplete_manager.deactivate();
                return;
            }
        }

        // Normal backspace
        self.input_editor.delete_char_before();
    }

    /// Activate file autocomplete
    fn activate_file_autocomplete(&mut self) {
        let trigger_pos = self.input_editor.cursor() - 1; // Position of @
        self.autocomplete_manager.activate(trigger_pos);

        tracing::info!(
            "🔍 ACTIVATED AUTOCOMPLETE: trigger_pos={}, cursor={}, text='{}'",
            trigger_pos,
            self.input_editor.cursor(),
            self.input_editor.text()
        );
    }

    /// Accept selected file completion
    fn accept_file_completion(&mut self) {
        // Get the selected match WITHOUT using accept_completion()
        // We do this manually to avoid the trailing space issue
        let selected = self.autocomplete_manager.selected_match().cloned();

        if let Some(selected) = selected {
            let trigger_pos = self.autocomplete_manager.trigger_pos().unwrap_or(0);
            let current_cursor = self.input_editor.cursor();

            tracing::info!(
                "🎯 ACCEPT: trigger_pos={}, cursor={}, path='{}'",
                trigger_pos,
                current_cursor,
                selected.path
            );

            // Calculate what to remove: from @+1 to current cursor
            let remove_start = trigger_pos + 1;
            let remove_end = current_cursor;

            tracing::info!(
                "🎯 REMOVE RANGE: {}..{} = '{}'",
                remove_start,
                remove_end,
                &self.input_editor.text()
                    [remove_start..remove_end.min(self.input_editor.text().len())]
            );

            // Use replace_range to atomically replace the query with the completion
            // Use selected.path WITHOUT trailing space
            if remove_end > remove_start {
                self.input_editor
                    .replace_range(remove_start, remove_end, &selected.path);
            } else {
                // Nothing to remove, just insert after @
                self.input_editor.set_cursor(remove_start);
                self.input_editor.insert_str(&selected.path);
            }

            // Add trailing space AFTER the completion
            self.input_editor.insert_char(' ');

            tracing::info!(
                "🎯 FINAL: '{}', cursor={}",
                self.input_editor.text(),
                self.input_editor.cursor()
            );
        }

        // Close autocomplete
        self.autocomplete_manager.deactivate();
    }

    fn handle_enter(&mut self) -> Result<(), CliError> {
        let text = self.input_editor.take_and_add_to_history();

        if text.is_empty() {
            return Ok(());
        }

        tracing::info!("Enter pressed with text: {:?}", text);

        // Check if it's a command (starts with /)
        if text.starts_with('/') {
            use crate::tui::commands::{CommandContext, CommandResult};

            // Create command context (clipboard is handled separately for now)
            let mut cmd_ctx = CommandContext::new(
                self.tui_bridge.chat_view().clone(),
                self.tui_bridge.session_manager(),
                self.tui_bridge.session_id(),
                self.tui_bridge.state_arc(),
                self.tui_bridge.messages(),
                self.tui_bridge.total_input_tokens_arc(),
                self.tui_bridge.total_output_tokens_arc(),
                None, // clipboard handled separately
            );

            // Execute command via registry
            match self.command_registry.parse_and_execute(&text, &mut cmd_ctx) {
                Ok(Some(result)) => {
                    // Update session_id if changed by command
                    self.tui_bridge
                        .session_id_arc()
                        .lock()
                        .unwrap()
                        .clone_from(&cmd_ctx.session_id);

                    match result {
                        CommandResult::Exit => {
                            self.running = false;
                            return Ok(());
                        }
                        CommandResult::ClearChat => {
                            // Already handled by command
                            return Ok(());
                        }
                        CommandResult::NewSession | CommandResult::LoadSession(_) => {
                            // Session was changed, sync state
                            *self.tui_bridge.messages().lock().unwrap() =
                                cmd_ctx.messages.lock().unwrap().clone();
                            *self.tui_bridge.total_input_tokens_arc().lock().unwrap() =
                                *cmd_ctx.total_input_tokens.lock().unwrap();
                            *self.tui_bridge.total_output_tokens_arc().lock().unwrap() =
                                *cmd_ctx.total_output_tokens.lock().unwrap();
                            return Ok(());
                        }
                        CommandResult::Continue
                        | CommandResult::Message(_)
                        | CommandResult::Share(_) => {
                            return Ok(());
                        }
                    }
                }
                Ok(None) => {
                    // Not a command, fall through to LLM processing
                }
                Err(e) => {
                    tracing::error!("Command error: {}", e);
                    // Show error to user instead of crashing
                    self.tui_bridge
                        .chat_view()
                        .lock()
                        .unwrap()
                        .add_message(Message::system(format!("Error: {}", e)));
                    return Ok(());
                }
            }
        }

        // Handle bare commands (without /) for backwards compatibility
        let text_lower = text.to_lowercase();
        if text_lower == "exit" || text_lower == "quit" {
            tracing::info!("Exit command detected, exiting");
            self.running = false;
            return Ok(());
        }

        if text_lower == "clear" {
            tracing::info!("Clear command detected");
            self.tui_bridge.chat_view().lock().unwrap().clear();
            return Ok(());
        }

        if text_lower == "help" {
            tracing::info!("Help command detected");
            let help_msg = Message::system(
                "Available commands:\n\
                 /help  - Show this help message\n\
                 /clear - Clear chat history\n\
                 /exit  - Exit the application\n\
                 /quit  - Exit the application\n\
                 /session list  - List all sessions\n\
                 /session new   - Create a new session\n\
                 /session load  <id> - Load a session by ID\n\
                 /share         - Copy session to clipboard (markdown)\n\
                 /share md      - Export session as markdown file\n\
                 /share json    - Export session as JSON file\n\
                 \n\
                 Page Up/Down - Scroll chat history\n\
                 Up/Down (empty input) - Navigate input history"
                    .to_string(),
            );
            self.tui_bridge
                .chat_view()
                .lock()
                .unwrap()
                .add_message(help_msg);
            return Ok(());
        }

        // Add user message to chat immediately for visual feedback
        self.tui_bridge.add_user_message(text.clone());

        // Get new operation ID and ensure state is Idle
        let operation_id = self.tui_bridge.next_operation_id();
        tracing::debug!("handle_enter: new operation_id={}", operation_id);
        self.tui_bridge.set_state(TuiState::Idle);

        // Create cancellation token for this operation
        let cancel_token = tokio_util::sync::CancellationToken::new();
        self.cancellation_token = Some(cancel_token.clone());

        // Clone Arcs for the spawned thread
        let messages = self.tui_bridge.messages();
        let agent_bridge = self.tui_bridge.agent_bridge_arc();
        let session_manager = self.tui_bridge.session_manager();
        let session_id = self.tui_bridge.session_id();
        let total_input_tokens = self.tui_bridge.total_input_tokens_arc();
        let total_output_tokens = self.tui_bridge.total_output_tokens_arc();

        tracing::debug!("Spawning LLM processing thread");

        // Spawn a thread to process the message without blocking the UI
        std::thread::spawn(move || {
            // Create a new tokio runtime for this thread
            let rt = tokio::runtime::Runtime::new().unwrap();

            // Safe: we're in a dedicated thread, this won't cause issues
            #[allow(clippy::await_holding_lock)]
            rt.block_on(async {
                // Check for cancellation BEFORE acquiring locks
                if cancel_token.is_cancelled() {
                    tracing::debug!("Operation cancelled before acquiring locks");
                    return;
                }

                // Try to acquire locks with timeout to avoid blocking indefinitely
                let messages_guard = {
                    let mut attempts = 0;
                    loop {
                        if cancel_token.is_cancelled() {
                            tracing::debug!("Operation cancelled while waiting for messages lock");
                            return;
                        }
                        match messages.try_lock() {
                            Ok(guard) => break guard,
                            Err(std::sync::TryLockError::WouldBlock) => {
                                attempts += 1;
                                if attempts > 50 {
                                    tracing::error!("Timeout waiting for messages lock");
                                    return;
                                }
                                tokio::time::sleep(std::time::Duration::from_millis(100)).await;
                            }
                            Err(e) => {
                                tracing::error!("Failed to lock messages: {}", e);
                                return;
                            }
                        }
                    }
                };

                let mut messages_guard = messages_guard;

                // Check cancellation again before acquiring bridge lock
                if cancel_token.is_cancelled() {
                    tracing::debug!("Operation cancelled before acquiring bridge lock");
                    return;
                }

                let bridge_guard = {
                    let mut attempts = 0;
                    loop {
                        if cancel_token.is_cancelled() {
                            tracing::debug!("Operation cancelled while waiting for bridge lock");
                            return;
                        }
                        match agent_bridge.try_lock() {
                            Ok(guard) => break guard,
                            Err(std::sync::TryLockError::WouldBlock) => {
                                attempts += 1;
                                if attempts > 50 {
                                    tracing::error!("Timeout waiting for bridge lock");
                                    return;
                                }
                                tokio::time::sleep(std::time::Duration::from_millis(100)).await;
                            }
                            Err(e) => {
                                tracing::error!("Failed to lock agent_bridge: {}", e);
                                return;
                            }
                        }
                    }
                };

                let mut bridge = bridge_guard;

                // Set cancellation token and operation ID
                bridge.set_cancellation_token(cancel_token.clone(), operation_id);

                match bridge.process_message(&text, &mut messages_guard).await {
                    Ok(_response) => {
                        // Don't sync ChatView here - it causes race conditions with ContentChunk events
                        // ChatView is already updated via ContentChunk events during streaming
                        // The messages_guard is the authoritative source for session persistence

                        // Auto-save session after successful response
                        let msgs = messages_guard.clone();
                        let input_tokens = *total_input_tokens.lock().unwrap();
                        let output_tokens = *total_output_tokens.lock().unwrap();

                        if let Err(e) = session_manager.lock().unwrap().save_session(
                            &session_id,
                            &msgs,
                            input_tokens,
                            output_tokens,
                        ) {
                            tracing::error!("✗ Failed to auto-save session {}: {}", session_id, e);
                        } else {
                            tracing::info!(
                                "✓ Session {} auto-saved ({} messages, {} in, {} out tokens)",
                                session_id,
                                msgs.len(),
                                input_tokens,
                                output_tokens
                            );
                        }
                    }
                    Err(e) => {
                        // Check if it was a cancellation
                        let error_msg = e.to_string();
                        if error_msg.contains("cancelled") {
                            tracing::info!("Request cancelled by user");
                        } else {
                            tracing::error!("LLM error: {}", e);
                        }
                    }
                }

                // Clear cancellation token
                bridge.clear_cancellation_token();
            });
        });

        Ok(())
    }

    /// Cancel current LLM operation
    fn cancel_current_operation(&mut self) {
        if let Some(ref token) = self.cancellation_token {
            token.cancel();
            tracing::debug!("Cancellation token triggered");

            // Increment operation ID to ignore subsequent events from old operation
            self.tui_bridge.next_operation_id();

            // Force reset TUI state to Idle
            self.tui_bridge.set_state(TuiState::Idle);

            // Update UI state
            self.status_message = "Operation cancelled".to_string();
            self.status_is_error = false;

            // Clear activity feed
            self.tui_bridge
                .activity_feed()
                .lock()
                .unwrap()
                .complete_all();

            // Add cancellation message to chat
            let cancel_msg = Message::system("⚠ Operation cancelled by user".to_string());
            self.tui_bridge
                .chat_view()
                .lock()
                .unwrap()
                .add_message(cancel_msg);
        }
        self.cancellation_token = None;
        // Reset ESC time via input_handler
        self.input_handler.reset_esc_time();
    }

    fn draw(&mut self) -> Result<(), CliError> {
        let chat_view = self.tui_bridge.chat_view().clone();
        let display_text = self.input_editor.display_text_combined();
        let cursor_pos = self.input_editor.cursor();
        let cursor_blink_state = self.input_handler.cursor_blink_state();
        let tui_bridge = &self.tui_bridge;
        let file_autocomplete = self.autocomplete_manager.to_legacy_state();

        self.terminal
            .draw(|f| {
                UiRenderer::render(
                    f,
                    f.area(),
                    &chat_view,
                    &display_text,
                    cursor_pos,
                    &self.status_message,
                    self.status_is_error,
                    cursor_blink_state,
                    tui_bridge,
                    &file_autocomplete,
                );
            })
            .map_err(|e| CliError::IoError(io::Error::other(e)))?;

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::agent_bridge::AgentBridge;
    use crate::tui::bridge::TuiBridge;
    use tokio::sync::mpsc;

    /// Create a test config for AgentBridge
    fn create_test_config() -> limit_llm::Config {
        use limit_llm::{BrowserConfigSection, ProviderConfig};
        let mut providers = std::collections::HashMap::new();
        providers.insert(
            "anthropic".to_string(),
            ProviderConfig {
                api_key: Some("test-key".to_string()),
                model: "claude-3-5-sonnet-20241022".to_string(),
                base_url: None,
                max_tokens: 4096,
                timeout: 60,
                max_iterations: 100,
                thinking_enabled: false,
                clear_thinking: true,
            },
        );
        limit_llm::Config {
            provider: "anthropic".to_string(),
            providers,
            browser: BrowserConfigSection::default(),
        }
    }

    #[test]
    fn test_tui_app_new() {
        let config = create_test_config();
        let agent_bridge = AgentBridge::new(config).unwrap();
        let (_tx, rx) = mpsc::unbounded_channel();

        let tui_bridge = TuiBridge::new(agent_bridge, rx).unwrap();
        let app = TuiApp::new(tui_bridge);
        assert!(app.is_ok());
    }
}