limit_cli/

tui_bridge.rs

use crate::agent_bridge::{AgentBridge, AgentEvent};
use crate::clipboard::ClipboardManager;
use crate::error::CliError;
use crate::file_finder::FileFinder;
use crate::session::SessionManager;
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::{
    calculate_popup_area, ActivityFeed, ChatView, FileAutocompleteWidget, FileMatchData, Message,
    Spinner,
};
use ratatui::{
    backend::CrosstermBackend,
    layout::{Constraint, Direction, Layout},
    style::{Color, Modifier, Style},
    text::{Line, Span},
    widgets::{Block, Borders, Paragraph, Wrap},
    Frame, Terminal,
};
use std::io;
use std::sync::{Arc, Mutex};
use tokio::sync::mpsc;

/// Maximum paste size to prevent memory issues (100KB)
const MAX_PASTE_SIZE: usize = 100 * 1024;

/// State for file autocomplete popup
#[derive(Debug, Clone)]
pub struct FileAutocompleteState {
    /// Whether autocomplete popup is visible
    pub is_active: bool,
    /// Query typed after @ (e.g., "Cargo" in "@Cargo")
    pub query: String,
    /// Start position of @ in input_text
    pub trigger_pos: usize,
    /// List of matching files
    pub matches: Vec<FileMatchData>,
    /// Currently selected index in matches
    pub selected_index: usize,
}

/// Debug log to file (bypasses tracing)
fn debug_log(msg: &str) {
    use std::fs::OpenOptions;
    use std::io::Write;
    if let Ok(mut file) = OpenOptions::new()
        .create(true)
        .append(true)
        .open(std::env::var("HOME").unwrap_or_else(|_| ".".to_string()) + "/.limit/logs/tui.log")
    {
        let timestamp = chrono::Local::now().format("%H:%M:%S%.3f");
        let _ = writeln!(file, "[{}] {}", timestamp, msg);
    }
}
/// TUI state for displaying agent events
#[derive(Debug, Clone, PartialEq, Default)]
pub enum TuiState {
    #[default]
    Idle,
    Thinking,
}

/// Bridge connecting limit-cli REPL to limit-tui components
pub struct TuiBridge {
    /// Agent bridge for processing messages (wrapped for thread-safe access)
    agent_bridge: Arc<Mutex<AgentBridge>>,
    /// Event receiver from the agent
    event_rx: mpsc::UnboundedReceiver<AgentEvent>,
    /// Current TUI state
    state: Arc<Mutex<TuiState>>,
    /// Chat view for displaying conversation
    chat_view: Arc<Mutex<ChatView>>,
    /// Activity feed for showing tool activities
    activity_feed: Arc<Mutex<ActivityFeed>>,
    /// Spinner for thinking state
    /// Spinner for thinking state
    spinner: Arc<Mutex<Spinner>>,
    /// Conversation history
    messages: Arc<Mutex<Vec<limit_llm::Message>>>,
    /// Total input tokens for the session
    total_input_tokens: Arc<Mutex<u64>>,
    /// Total output tokens for the session
    total_output_tokens: Arc<Mutex<u64>>,
    /// Session manager for persistence
    session_manager: Arc<Mutex<SessionManager>>,
    /// Current session ID
    session_id: Arc<Mutex<String>>,
    /// Current operation ID (to ignore events from old operations)
    operation_id: Arc<Mutex<u64>>,
}

impl TuiBridge {
    /// Create a new TuiBridge with the given agent bridge and event channel
    pub fn new(
        agent_bridge: AgentBridge,
        event_rx: mpsc::UnboundedReceiver<AgentEvent>,
    ) -> Result<Self, CliError> {
        let session_manager = SessionManager::new().map_err(|e| {
            CliError::ConfigError(format!("Failed to create session manager: {}", e))
        })?;

        // Always create a new session on TUI startup
        let session_id = session_manager
            .create_new_session()
            .map_err(|e| CliError::ConfigError(format!("Failed to create session: {}", e)))?;
        tracing::info!("Created new TUI session: {}", session_id);

        // Start with empty messages - never load previous session
        let messages: Vec<limit_llm::Message> = Vec::new();

        // Get token counts from session info
        let sessions = session_manager.list_sessions().unwrap_or_default();
        let session_info = sessions.iter().find(|s| s.id == session_id);
        let initial_input = session_info.map(|s| s.total_input_tokens).unwrap_or(0);
        let initial_output = session_info.map(|s| s.total_output_tokens).unwrap_or(0);

        let chat_view = Arc::new(Mutex::new(ChatView::new()));

        // Add loaded messages to chat view for display
        for msg in &messages {
            match msg.role {
                limit_llm::Role::User => {
                    let chat_msg = Message::user(msg.content.clone().unwrap_or_default());
                    chat_view.lock().unwrap().add_message(chat_msg);
                }
                limit_llm::Role::Assistant => {
                    let content = msg.content.clone().unwrap_or_default();
                    let chat_msg = Message::assistant(content);
                    chat_view.lock().unwrap().add_message(chat_msg);
                }
                limit_llm::Role::System => {
                    // Skip system messages in display
                }
                limit_llm::Role::Tool => {
                    // Skip tool messages in display
                }
            }
        }

        tracing::info!("Loaded {} messages into chat view", messages.len());

        // Add system message to indicate this is a new session
        let session_short_id = format!("...{}", &session_id[session_id.len().saturating_sub(8)..]);
        let welcome_msg =
            Message::system(format!("🆕 New TUI session started: {}", session_short_id));
        chat_view.lock().unwrap().add_message(welcome_msg);

        // Add model info as system message
        let model_name = agent_bridge.model().to_string();
        if !model_name.is_empty() {
            let model_msg = Message::system(format!("Using model: {}", model_name));
            chat_view.lock().unwrap().add_message(model_msg);
        }

        Ok(Self {
            agent_bridge: Arc::new(Mutex::new(agent_bridge)),
            event_rx,
            state: Arc::new(Mutex::new(TuiState::Idle)),
            chat_view,
            activity_feed: Arc::new(Mutex::new(ActivityFeed::new())),
            spinner: Arc::new(Mutex::new(Spinner::new("Thinking..."))),
            messages: Arc::new(Mutex::new(messages)),
            total_input_tokens: Arc::new(Mutex::new(initial_input)),
            total_output_tokens: Arc::new(Mutex::new(initial_output)),
            session_manager: Arc::new(Mutex::new(session_manager)),
            session_id: Arc::new(Mutex::new(session_id)),
            operation_id: Arc::new(Mutex::new(0)),
        })
    }

    /// Get a clone of the agent bridge Arc for spawning tasks
    pub fn agent_bridge_arc(&self) -> Arc<Mutex<AgentBridge>> {
        self.agent_bridge.clone()
    }

    /// Get locked access to the agent bridge (for compatibility)
    #[allow(dead_code)]
    pub fn agent_bridge(&self) -> std::sync::MutexGuard<'_, AgentBridge> {
        self.agent_bridge.lock().unwrap()
    }

    /// Get the current TUI state
    pub fn state(&self) -> TuiState {
        self.state.lock().unwrap().clone()
    }

    /// Get a reference to the chat view
    pub fn chat_view(&self) -> &Arc<Mutex<ChatView>> {
        &self.chat_view
    }

    /// Get a reference to the spinner
    pub fn spinner(&self) -> &Arc<Mutex<Spinner>> {
        &self.spinner
    }

    /// Get a reference to the activity feed
    pub fn activity_feed(&self) -> &Arc<Mutex<ActivityFeed>> {
        &self.activity_feed
    }

    /// Process events from the agent and update TUI state
    pub fn process_events(&mut self) -> Result<(), CliError> {
        let mut event_count = 0;
        let current_op_id = self.operation_id();

        while let Ok(event) = self.event_rx.try_recv() {
            event_count += 1;

            // Get operation_id from event
            let event_op_id = match &event {
                AgentEvent::Thinking { operation_id } => *operation_id,
                AgentEvent::ToolStart { operation_id, .. } => *operation_id,
                AgentEvent::ToolComplete { operation_id, .. } => *operation_id,
                AgentEvent::ContentChunk { operation_id, .. } => *operation_id,
                AgentEvent::Done { operation_id } => *operation_id,
                AgentEvent::Cancelled { operation_id } => *operation_id,
                AgentEvent::Error { operation_id, .. } => *operation_id,
                AgentEvent::TokenUsage { operation_id, .. } => *operation_id,
            };

            debug_log(&format!(
                "process_events: event_op_id={}, current_op_id={}, event={:?}",
                event_op_id, current_op_id, std::mem::discriminant(&event)
            ));

            // Ignore events from old operations
            if event_op_id != current_op_id {
                debug_log(&format!(
                    "process_events: Ignoring event from old operation {} (current: {})",
                    event_op_id, current_op_id
                ));
                continue;
            }

            match event {
                AgentEvent::Thinking { operation_id: _ } => {
                    debug_log("process_events: Thinking event received - setting state to Thinking");
                    *self.state.lock().unwrap() = TuiState::Thinking;
                    debug_log(&format!("process_events: state is now {:?}", self.state()));
                }
                AgentEvent::ToolStart {
                    operation_id: _,
                    name,
                    args,
                } => {
                    debug_log(&format!("process_events: ToolStart event - {}", name));
                    let activity_msg = Self::format_activity_message(&name, &args);
                    // Add to activity feed instead of changing state
                    self.activity_feed.lock().unwrap().add(activity_msg, true);
                }
                AgentEvent::ToolComplete {
                    operation_id: _,
                    name: _,
                    result: _,
                } => {
                    debug_log("process_events: ToolComplete event");
                    // Mark current activity as complete
                    self.activity_feed.lock().unwrap().complete_current();
                }
                AgentEvent::ContentChunk {
                    operation_id: _,
                    chunk,
                } => {
                    debug_log(&format!(
                        "process_events: ContentChunk event ({} chars)",
                        chunk.len()
                    ));
                    self.chat_view
                        .lock()
                        .unwrap()
                        .append_to_last_assistant(&chunk);
                }
                AgentEvent::Done { operation_id: _ } => {
                    debug_log("process_events: Done event received");
                    *self.state.lock().unwrap() = TuiState::Idle;
                    // Mark all activities as complete when LLM finishes
                    self.activity_feed.lock().unwrap().complete_all();
                }
                AgentEvent::Cancelled { operation_id: _ } => {
                    debug_log("process_events: Cancelled event received");
                    *self.state.lock().unwrap() = TuiState::Idle;
                    // Mark all activities as complete
                    self.activity_feed.lock().unwrap().complete_all();
                }
                AgentEvent::Error {
                    operation_id: _,
                    message,
                } => {
                    debug_log(&format!("process_events: Error event - {}", message));
                    // Reset state to Idle so user can continue
                    *self.state.lock().unwrap() = TuiState::Idle;
                    let chat_msg = Message::system(format!("Error: {}", message));
                    self.chat_view.lock().unwrap().add_message(chat_msg);
                }
                AgentEvent::TokenUsage {
                    operation_id: _,
                    input_tokens,
                    output_tokens,
                } => {
                    debug_log(&format!(
                        "process_events: TokenUsage event - in={}, out={}",
                        input_tokens, output_tokens
                    ));
                    // Accumulate token counts for display
                    *self.total_input_tokens.lock().unwrap() += input_tokens;
                    *self.total_output_tokens.lock().unwrap() += output_tokens;
                }
            }
        }
        if event_count > 0 {
            debug_log(&format!("process_events: processed {} events", event_count));
        }
        Ok(())
    }

    fn format_activity_message(tool_name: &str, args: &serde_json::Value) -> String {
        match tool_name {
            "file_read" => args
                .get("path")
                .and_then(|p| p.as_str())
                .map(|p| format!("Reading {}...", Self::truncate_path(p, 40)))
                .unwrap_or_else(|| "Reading file...".to_string()),
            "file_write" => args
                .get("path")
                .and_then(|p| p.as_str())
                .map(|p| format!("Writing {}...", Self::truncate_path(p, 40)))
                .unwrap_or_else(|| "Writing file...".to_string()),
            "file_edit" => args
                .get("path")
                .and_then(|p| p.as_str())
                .map(|p| format!("Editing {}...", Self::truncate_path(p, 40)))
                .unwrap_or_else(|| "Editing file...".to_string()),
            "bash" => args
                .get("command")
                .and_then(|c| c.as_str())
                .map(|c| format!("Running {}...", Self::truncate_command(c, 30)))
                .unwrap_or_else(|| "Executing command...".to_string()),
            "git_status" => "Checking git status...".to_string(),
            "git_diff" => "Checking git diff...".to_string(),
            "git_log" => "Checking git log...".to_string(),
            "git_add" => "Staging files...".to_string(),
            "git_commit" => "Creating commit...".to_string(),
            "git_push" => "Pushing to remote...".to_string(),
            "git_pull" => "Pulling from remote...".to_string(),
            "git_clone" => args
                .get("url")
                .and_then(|u| u.as_str())
                .map(|u| format!("Cloning {}...", Self::truncate_path(u, 40)))
                .unwrap_or_else(|| "Cloning repository...".to_string()),
            "grep" => args
                .get("pattern")
                .and_then(|p| p.as_str())
                .map(|p| format!("Searching for '{}'...", Self::truncate_command(p, 30)))
                .unwrap_or_else(|| "Searching...".to_string()),
            "ast_grep" => args
                .get("pattern")
                .and_then(|p| p.as_str())
                .map(|p| format!("AST searching '{}'...", Self::truncate_command(p, 25)))
                .unwrap_or_else(|| "AST searching...".to_string()),
            "lsp" => args
                .get("command")
                .and_then(|c| c.as_str())
                .map(|c| format!("Running LSP {}...", c))
                .unwrap_or_else(|| "Running LSP...".to_string()),
            _ => format!("Executing {}...", tool_name),
        }
    }

    fn truncate_path(s: &str, max_len: usize) -> String {
        if s.len() <= max_len {
            s.to_string()
        } else {
            format!("...{}", &s[s.len().saturating_sub(max_len - 3)..])
        }
    }

    fn truncate_command(s: &str, max_len: usize) -> String {
        if s.len() <= max_len {
            s.to_string()
        } else {
            format!("{}...", &s[..max_len.saturating_sub(3)])
        }
    }

    /// Add a user message to the chat
    pub fn add_user_message(&self, content: String) {
        let msg = Message::user(content);
        self.chat_view.lock().unwrap().add_message(msg);
    }

    /// Tick the spinner animation
    pub fn tick_spinner(&self) {
        self.spinner.lock().unwrap().tick();
    }

    /// Check if agent is busy
    pub fn is_busy(&self) -> bool {
        !matches!(self.state(), TuiState::Idle)
    }

    /// Get current operation ID
    pub fn operation_id(&self) -> u64 {
        self.operation_id.lock().map(|id| *id).unwrap_or(0)
    }

    /// Increment and get new operation ID
    pub fn next_operation_id(&self) -> u64 {
        if let Ok(mut id) = self.operation_id.lock() {
            *id += 1;
            *id
        } else {
            0
        }
    }

    /// Get total input tokens for the session
    pub fn total_input_tokens(&self) -> u64 {
        self.total_input_tokens
            .lock()
            .map(|guard| *guard)
            .unwrap_or(0)
    }

    /// Get total output tokens for the session
    pub fn total_output_tokens(&self) -> u64 {
        self.total_output_tokens
            .lock()
            .map(|guard| *guard)
            .unwrap_or(0)
    }

    /// Get the current session ID
    pub fn session_id(&self) -> String {
        self.session_id
            .lock()
            .map(|guard| guard.clone())
            .unwrap_or_else(|_| String::from("unknown"))
    }

    /// Save the current session
    pub fn save_session(&self) -> Result<(), CliError> {
        let session_id = self
            .session_id
            .lock()
            .map(|guard| guard.clone())
            .unwrap_or_else(|_| String::from("unknown"));

        let messages = self
            .messages
            .lock()
            .map(|guard| guard.clone())
            .unwrap_or_default();

        let input_tokens = self
            .total_input_tokens
            .lock()
            .map(|guard| *guard)
            .unwrap_or(0);

        let output_tokens = self
            .total_output_tokens
            .lock()
            .map(|guard| *guard)
            .unwrap_or(0);

        tracing::debug!(
            "Saving session {} with {} messages, {} in tokens, {} out tokens",
            session_id,
            messages.len(),
            input_tokens,
            output_tokens
        );

        let session_manager = self.session_manager.lock().map_err(|e| {
            CliError::ConfigError(format!("Failed to acquire session manager lock: {}", e))
        })?;

        session_manager.save_session(&session_id, &messages, input_tokens, output_tokens)?;
        tracing::info!(
            "✓ Session {} saved successfully ({} messages, {} in tokens, {} out tokens)",
            session_id,
            messages.len(),
            input_tokens,
            output_tokens
        );
        Ok(())
    }
}

/// TUI Application for running the limit CLI in a terminal UI
pub struct TuiApp {
    tui_bridge: TuiBridge,
    terminal: Terminal<CrosstermBackend<io::Stdout>>,
    running: bool,
    input_text: String,
    cursor_pos: usize,
    status_message: String,
    status_is_error: bool,
    cursor_blink_state: bool,
    cursor_blink_timer: std::time::Instant,
    /// Mouse selection state
    mouse_selection_start: Option<(u16, u16)>,
    /// Clipboard manager
    clipboard: Option<ClipboardManager>,
    /// File autocomplete state
    file_autocomplete: Option<FileAutocompleteState>,
    /// File finder instance
    file_finder: FileFinder,
    /// Last ESC press time for double-ESC detection
    last_esc_time: Option<std::time::Instant>,
    /// Cancellation token for current LLM operation
    cancellation_token: Option<tokio_util::sync::CancellationToken>,
}

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);

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

        // Initialize file finder with current directory
        let working_dir = std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from("."));
        let file_finder = FileFinder::new(working_dir);

        Ok(Self {
            tui_bridge,
            terminal,
            running: true,
            input_text: String::new(),
            cursor_pos: 0,
            status_message: "Ready - Type a message and press Enter".to_string(),
            status_is_error: false,
            cursor_blink_state: true,
            cursor_blink_timer: std::time::Instant::now(),
            mouse_selection_start: None,
            clipboard,
            file_autocomplete: None,
            file_finder,
            last_esc_time: None,
            cancellation_token: None,
        })
    }

    /// 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 crossterm::event::poll(std::time::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
                        debug_log(&format!(
                            "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) => {
                                debug_log(&format!(
                                    "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();
                                debug_log(&format!(
                                    "  render_positions count: {}",
                                    chat.render_position_count()
                                ));
                                if let Some((msg_idx, char_offset)) =
                                    chat.screen_to_text_pos(mouse.column, mouse.row)
                                {
                                    debug_log(&format!(
                                        "  -> 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 {
                                    debug_log("  -> 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);
        }

        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) {
        // Enforce size limit to prevent memory issues
        let text = if text.len() > MAX_PASTE_SIZE {
            self.status_message = "Paste truncated (too large)".to_string();
            self.status_is_error = true;
            // Find valid UTF-8 boundary at approximately MAX_PASTE_SIZE
            &text[..text
                .char_indices()
                .nth(MAX_PASTE_SIZE)
                .map(|(i, _)| i)
                .unwrap_or(text.len())]
        } else {
            text
        };

        // Normalize newlines (some terminals convert \n to \r)
        let normalized = text.replace("\r", "\n");
        self.input_text.insert_str(self.cursor_pos, &normalized);
        self.cursor_pos += normalized.len();
    }

    /// 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);
            debug_log(&format!("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);
            debug_log(&format!(
                "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) {
        // Blink every 500ms for standard terminal cursor behavior
        if self.cursor_blink_timer.elapsed().as_millis() > 500 {
            self.cursor_blink_state = !self.cursor_blink_state;
            self.cursor_blink_timer = std::time::Instant::now();
        }
    }

    fn handle_key_event(&mut self, key: KeyEvent) -> Result<(), CliError> {
        // Direct file logging (always works)
        debug_log(&format!(
            "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')) {
            debug_log(&format!(
                ">>> 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') {
            debug_log("✓ Copy shortcut CONFIRMED - processing...");
            let mut chat = self.tui_bridge.chat_view().lock().unwrap();
            let has_selection = chat.has_selection();
            debug_log(&format!("has_selection={}", has_selection));

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

            // No selection - do nothing (Ctrl+C is only for copying text)
            debug_log("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() {
            debug_log("✓ Paste shortcut CONFIRMED - processing...");
            if let Some(ref clipboard) = self.clipboard {
                debug_log("Attempting to read from clipboard...");
                match clipboard.get_text() {
                    Ok(text) if !text.is_empty() => {
                        debug_log(&format!("Read {} chars from clipboard", text.len()));
                        self.insert_paste(&text);
                    }
                    Ok(_) => {
                        debug_log("Clipboard is empty");
                    } // Empty clipboard
                    Err(e) => {
                        debug_log(&format!("✗ Failed to read clipboard: {}", e));
                        self.status_message = format!("Could not read clipboard: {}", e);
                        self.status_is_error = true;
                    }
                }
            } else {
                debug_log("✗ 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)
        if let Some(ref mut ac) = self.file_autocomplete {
            if ac.is_active {
                match key.code {
                    KeyCode::Up => {
                        if ac.selected_index > 0 {
                            ac.selected_index -= 1;
                        }
                        return Ok(());
                    }
                    KeyCode::Down => {
                        if ac.selected_index + 1 < ac.matches.len() {
                            ac.selected_index += 1;
                        }
                        return Ok(());
                    }
                    KeyCode::Enter | KeyCode::Tab => {
                        // Accept selected completion
                        self.accept_file_completion();
                        return Ok(());
                    }
                    KeyCode::Esc => {
                        // Cancel autocomplete
                        self.file_autocomplete = None;
                        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.file_autocomplete.is_some() {
                self.file_autocomplete = None;
            } else if self.tui_bridge.is_busy() {
                // Double-ESC to cancel current operation
                let now = std::time::Instant::now();
                let should_cancel = if let Some(last_esc) = self.last_esc_time {
                    now.duration_since(last_esc) < std::time::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.last_esc_time = Some(now);
                }
            } else {
                debug_log("Esc pressed, exiting");
                self.running = false;
            }
            return Ok(());
        }

        // Allow scrolling even when agent is busy
        // 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 => {
                let mut chat = self.tui_bridge.chat_view().lock().unwrap();
                chat.scroll_up();
                return Ok(());
            }
            KeyCode::Down => {
                // Otherwise scroll chat
                let mut chat = self.tui_bridge.chat_view().lock().unwrap();
                chat.scroll_down();
                return Ok(());
            }
            _ => {}
        }

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

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

        match key.code {
            KeyCode::Delete => {
                if self.cursor_pos < self.input_text.len() {
                    let next_pos = self.next_char_pos();
                    self.input_text.drain(self.cursor_pos..next_pos);
                    debug_log(&format!("Delete: input now: {:?}", self.input_text));
                }
            }
            KeyCode::Left => {
                if self.cursor_pos > 0 {
                    self.cursor_pos = self.prev_char_pos();
                }
            }
            KeyCode::Right => {
                if self.cursor_pos < self.input_text.len() {
                    self.cursor_pos = self.next_char_pos();
                }
            }
            KeyCode::Home => {
                self.cursor_pos = 0;
            }
            KeyCode::End => {
                self.cursor_pos = self.input_text.len();
            }
            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_text.insert(self.cursor_pos, '@');
                    self.cursor_pos += 1;

                    // Activate autocomplete
                    self.activate_file_autocomplete();
                } else {
                    // Check if autocomplete is active
                    let is_autocomplete_active = self
                        .file_autocomplete
                        .as_ref()
                        .map(|ac| ac.is_active)
                        .unwrap_or(false);

                    if is_autocomplete_active {
                        // Clone query to avoid borrow issues
                        let query = self
                            .file_autocomplete
                            .as_ref()
                            .map(|ac| {
                                let mut q = ac.query.clone();
                                q.push(c);
                                q
                            })
                            .unwrap_or_default();

                        // Get matches
                        let matches = self.get_file_matches(&query);

                        // Update autocomplete state
                        if let Some(ref mut ac) = self.file_autocomplete {
                            ac.query.push(c);
                            ac.matches = matches;
                            ac.selected_index = 0;
                        }

                        // Also insert the character in input
                        self.input_text.insert(self.cursor_pos, c);
                        self.cursor_pos += c.len_utf8();
                    } else {
                        // Normal character insertion
                        self.input_text.insert(self.cursor_pos, c);
                        self.cursor_pos += c.len_utf8();
                    }
                }
            }
            _ => {
                // 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 {
            debug_log("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 {
            debug_log("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' {
                debug_log(&format!("Backspace detected via char code: {}", c as u8));
                self.delete_char_before_cursor();
                return true;
            }
        }

        false
    }

    fn delete_char_before_cursor(&mut self) {
        debug_log(&format!(
            "delete_char: cursor={}, len={}, input={:?}",
            self.cursor_pos,
            self.input_text.len(),
            self.input_text
        ));

        // If autocomplete is active, handle backspace specially
        let should_close_autocomplete = if let Some(ref ac) = self.file_autocomplete {
            if ac.is_active {
                // Check if query is empty
                ac.query.is_empty()
            } else {
                false
            }
        } else {
            false
        };

        if should_close_autocomplete {
            // Need to delete the @ from input
            if self.cursor_pos > 0 {
                let prev_pos = self.prev_char_pos();
                if &self.input_text[prev_pos..self.cursor_pos] == "@" {
                    self.input_text.drain(prev_pos..self.cursor_pos);
                    self.cursor_pos = prev_pos;
                    self.file_autocomplete = None;
                    return;
                }
            }
        }

        // Update autocomplete query if active
        if self
            .file_autocomplete
            .as_ref()
            .map(|ac| ac.is_active && !ac.query.is_empty())
            .unwrap_or(false)
        {
            let new_query = self
                .file_autocomplete
                .as_ref()
                .map(|ac| {
                    let mut q = ac.query.clone();
                    q.pop();
                    q
                })
                .unwrap_or_default();

            let matches = self.get_file_matches(&new_query);

            if let Some(ref mut ac) = self.file_autocomplete {
                ac.query.pop();
                ac.matches = matches;
                ac.selected_index = 0;
            }
        }

        if self.cursor_pos > 0 {
            let prev_pos = self.prev_char_pos();
            debug_log(&format!("draining {}..{}", prev_pos, self.cursor_pos));
            self.input_text.drain(prev_pos..self.cursor_pos);
            self.cursor_pos = prev_pos;
            debug_log(&format!(
                "after delete: cursor={}, input={:?}",
                self.cursor_pos, self.input_text
            ));
        } else {
            debug_log("cursor at 0, nothing to delete");
        }
    }

    /// Activate file autocomplete
    fn activate_file_autocomplete(&mut self) {
        let matches = self.get_file_matches("");

        self.file_autocomplete = Some(FileAutocompleteState {
            is_active: true,
            query: String::new(),
            trigger_pos: self.cursor_pos - 1, // Position of @
            matches,
            selected_index: 0,
        });

        debug_log(&format!(
            "Activated autocomplete at pos {}",
            self.cursor_pos - 1
        ));
    }

    /// Get file matches for autocomplete
    fn get_file_matches(&mut self, query: &str) -> Vec<FileMatchData> {
        let files = self.file_finder.scan_files().clone();
        let matches = self.file_finder.filter_files(&files, query);

        matches
            .into_iter()
            .map(|m| FileMatchData {
                path: m.path.to_string_lossy().to_string(),
                is_dir: m.is_dir,
            })
            .collect()
    }

    /// Accept selected file completion
    fn accept_file_completion(&mut self) {
        if let Some(ref ac) = self.file_autocomplete {
            if let Some(selected) = ac.matches.get(ac.selected_index) {
                // Replace @query with @path
                let end_pos = self.cursor_pos;

                // Calculate how much to remove (from @ to current cursor)
                let remove_start = ac.trigger_pos;

                // Remove the query part (keep the @)
                self.input_text.drain(remove_start + 1..end_pos);
                self.cursor_pos = remove_start + 1;

                // Insert the selected path
                self.input_text.insert_str(self.cursor_pos, &selected.path);
                self.cursor_pos += selected.path.len();

                // Add space after completion for better UX
                self.input_text.insert(self.cursor_pos, ' ');
                self.cursor_pos += 1;

                debug_log(&format!(
                    "Accepted completion: {} -> input now: {:?}",
                    selected.path, self.input_text
                ));
            }
        }

        // Close autocomplete
        self.file_autocomplete = None;
    }

    fn handle_enter(&mut self) -> Result<(), CliError> {
        let text = self.input_text.trim().to_string();

        // Clear input FIRST for immediate visual feedback
        self.input_text.clear();
        self.cursor_pos = 0;

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

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

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

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

        if text_lower == "/help" || 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"
                    .to_string(),
            );
            self.tui_bridge
                .chat_view()
                .lock()
                .unwrap()
                .add_message(help_msg);
            return Ok(());
        }

        // Handle session commands
        if text_lower.starts_with("/session ") {
            let session_cmd = text.strip_prefix("/session ").unwrap();
            if session_cmd.trim() == "list" {
                self.handle_session_list()?;
                return Ok(());
            } else if session_cmd.trim() == "new" {
                self.handle_session_new()?;
                return Ok(());
            } else if session_cmd.starts_with("load ") {
                let session_id = session_cmd.strip_prefix("load ").unwrap().trim();
                self.handle_session_load(session_id)?;
                return Ok(());
            } else {
                let error_msg = Message::system(
                    "Usage: /session list, /session new, /session load <id>".to_string(),
                );
                self.tui_bridge
                    .chat_view()
                    .lock()
                    .unwrap()
                    .add_message(error_msg);
                return Ok(());
            }
        }

        // Handle share commands
        if text_lower == "/share" || text_lower.starts_with("/share ") {
            let share_cmd = text.strip_prefix("/share ").unwrap_or("").trim();
            self.handle_share(share_cmd)?;
            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();
        debug_log(&format!("handle_enter: new operation_id={}", operation_id));
        *self.tui_bridge.state.lock().unwrap() = 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.clone();
        let agent_bridge = self.tui_bridge.agent_bridge_arc();
        let session_manager = self.tui_bridge.session_manager.clone();
        let session_id = self.tui_bridge.session_id();
        let total_input_tokens = self.tui_bridge.total_input_tokens.clone();
        let total_output_tokens = self.tui_bridge.total_output_tokens.clone();

        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();
            debug_log("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.state.lock().unwrap() = 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;
        self.last_esc_time = None;
    }

    /// Handle /session list command
    fn handle_session_list(&self) -> Result<(), CliError> {
        tracing::info!("Session list command detected");
        let session_manager = self.tui_bridge.session_manager.lock().unwrap();
        let current_session_id = self.tui_bridge.session_id();

        match session_manager.list_sessions() {
            Ok(sessions) => {
                if sessions.is_empty() {
                    let msg = Message::system("No sessions found.".to_string());
                    self.tui_bridge.chat_view().lock().unwrap().add_message(msg);
                } else {
                    let mut output = vec!["Sessions (most recent first):".to_string()];
                    for (i, session) in sessions.iter().enumerate() {
                        let current = if session.id == current_session_id {
                            " (current)"
                        } else {
                            ""
                        };
                        let short_id = if session.id.len() > 8 {
                            &session.id[..8]
                        } else {
                            &session.id
                        };
                        output.push(format!(
                            "  {}. {}{} - {} messages, {} in tokens, {} out tokens",
                            i + 1,
                            short_id,
                            current,
                            session.message_count,
                            session.total_input_tokens,
                            session.total_output_tokens
                        ));
                    }
                    let msg = Message::system(output.join("\n"));
                    self.tui_bridge.chat_view().lock().unwrap().add_message(msg);
                }
            }
            Err(e) => {
                let msg = Message::system(format!("Error listing sessions: {}", e));
                self.tui_bridge.chat_view().lock().unwrap().add_message(msg);
            }
        }
        Ok(())
    }

    /// Handle /session new command
    fn handle_session_new(&mut self) -> Result<(), CliError> {
        tracing::info!("Session new command detected");

        // Save current session (release lock before proceeding)
        let save_result = self.tui_bridge.save_session();
        if let Err(e) = &save_result {
            tracing::error!("Failed to save current session: {}", e);
            let msg = Message::system(format!("⚠ Warning: Failed to save current session: {}", e));
            if let Ok(mut chat) = self.tui_bridge.chat_view.try_lock() {
                chat.add_message(msg);
            }
        }

        // Create new session (separate lock scope)
        let new_session_id = {
            let session_manager = self.tui_bridge.session_manager.lock().map_err(|e| {
                CliError::ConfigError(format!("Failed to acquire session manager lock: {}", e))
            })?;

            session_manager
                .create_new_session()
                .map_err(|e| CliError::ConfigError(format!("Failed to create session: {}", e)))?
        };

        let old_session_id = self.tui_bridge.session_id();

        // Update session ID
        if let Ok(mut id_guard) = self.tui_bridge.session_id.try_lock() {
            *id_guard = new_session_id.clone();
        }

        // Clear messages and reset token counts (separate locks)
        if let Ok(mut messages_guard) = self.tui_bridge.messages.try_lock() {
            messages_guard.clear();
        }
        if let Ok(mut input_guard) = self.tui_bridge.total_input_tokens.try_lock() {
            *input_guard = 0;
        }
        if let Ok(mut output_guard) = self.tui_bridge.total_output_tokens.try_lock() {
            *output_guard = 0;
        }

        // IMPORTANT: Also clear the chat view to prevent duplicate messages
        if let Ok(mut chat) = self.tui_bridge.chat_view.try_lock() {
            chat.clear();
        }

        tracing::info!(
            "Created new session: {} (old: {})",
            new_session_id,
            old_session_id
        );

        // Add system message
        let session_short_id = if new_session_id.len() > 8 {
            &new_session_id[new_session_id.len().saturating_sub(8)..]
        } else {
            &new_session_id
        };
        let msg = Message::system(format!("🆕 New session created: {}", session_short_id));

        if let Ok(mut chat) = self.tui_bridge.chat_view.try_lock() {
            chat.add_message(msg);
        }

        Ok(())
    }

    /// Handle /session load <id> command
    fn handle_session_load(&mut self, session_id: &str) -> Result<(), CliError> {
        tracing::info!("Session load command detected for session: {}", session_id);

        // Save current session first (release lock before proceeding)
        let save_result = self.tui_bridge.save_session();
        if let Err(e) = &save_result {
            tracing::error!("Failed to save current session: {}", e);
            let msg = Message::system(format!("⚠ Warning: Failed to save current session: {}", e));
            if let Ok(mut chat) = self.tui_bridge.chat_view.try_lock() {
                chat.add_message(msg);
            }
        }

        // Find session ID from partial match (acquire locks separately to avoid deadlock)
        let (full_session_id, session_info, messages) = {
            let session_manager = self.tui_bridge.session_manager.lock().map_err(|e| {
                CliError::ConfigError(format!("Failed to acquire session manager lock: {}", e))
            })?;

            let sessions = session_manager
                .list_sessions()
                .map_err(|e| CliError::ConfigError(format!("Failed to list sessions: {}", e)))?;

            let matched_session = if session_id.len() >= 8 {
                // Try exact match first
                sessions
                    .iter()
                    .find(|s| s.id == session_id)
                    // Then try prefix match
                    .or_else(|| sessions.iter().find(|s| s.id.starts_with(session_id)))
            } else {
                // Try prefix match for short IDs
                sessions.iter().find(|s| s.id.starts_with(session_id))
            };

            match matched_session {
                Some(info) => {
                    let full_id = info.id.clone();
                    // Load messages within the same lock scope
                    let msgs = session_manager.load_session(&full_id).map_err(|e| {
                        CliError::ConfigError(format!("Failed to load session {}: {}", full_id, e))
                    })?;
                    (full_id, info.clone(), msgs)
                }
                None => {
                    let msg = Message::system(format!("❌ Session not found: {}", session_id));
                    if let Ok(mut chat) = self.tui_bridge.chat_view.try_lock() {
                        chat.add_message(msg);
                    }
                    return Ok(());
                }
            }
        };

        // Update session ID and token counts (separate locks)
        if let Ok(mut id_guard) = self.tui_bridge.session_id.try_lock() {
            *id_guard = full_session_id.clone();
        }
        if let Ok(mut input_guard) = self.tui_bridge.total_input_tokens.try_lock() {
            *input_guard = session_info.total_input_tokens;
        }
        if let Ok(mut output_guard) = self.tui_bridge.total_output_tokens.try_lock() {
            *output_guard = session_info.total_output_tokens;
        }

        // Update messages in TUI bridge
        if let Ok(mut messages_guard) = self.tui_bridge.messages.try_lock() {
            *messages_guard = messages.clone();
        }

        // Clear chat view and reload messages
        if let Ok(mut chat) = self.tui_bridge.chat_view.try_lock() {
            chat.clear();

            // Reload messages into chat view (no additional locks needed)
            for msg in &messages {
                match msg.role {
                    limit_llm::Role::User => {
                        let content = msg.content.as_deref().unwrap_or("");
                        let chat_msg = Message::user(content.to_string());
                        chat.add_message(chat_msg);
                    }
                    limit_llm::Role::Assistant => {
                        let content = msg.content.as_deref().unwrap_or("");
                        let chat_msg = Message::assistant(content.to_string());
                        chat.add_message(chat_msg);
                    }
                    _ => {}
                }
            }

            tracing::info!(
                "Loaded session: {} ({} messages)",
                full_session_id,
                messages.len()
            );

            // Add system message
            let session_short_id = if full_session_id.len() > 8 {
                &full_session_id[full_session_id.len().saturating_sub(8)..]
            } else {
                &full_session_id
            };
            let msg = Message::system(format!(
                "📂 Loaded session: {} ({} messages, {} in tokens, {} out tokens)",
                session_short_id,
                messages.len(),
                session_info.total_input_tokens,
                session_info.total_output_tokens
            ));
            chat.add_message(msg);
        }

        Ok(())
    }

    /// Handle /share command
    fn handle_share(&mut self, format_str: &str) -> Result<(), CliError> {
        use crate::session_share::{ExportFormat, SessionShare};

        tracing::info!("Share command detected with format: {:?}", format_str);

        // Determine export format
        let format = match format_str.to_lowercase().as_str() {
            "" | "clipboard" | "cb" => ExportFormat::Markdown,
            "md" | "markdown" => ExportFormat::Markdown,
            "json" => ExportFormat::Json,
            _ => {
                let msg = Message::system(
                    "Invalid format. Use: /share, /share md, /share json".to_string(),
                );
                self.tui_bridge.chat_view().lock().unwrap().add_message(msg);
                return Ok(());
            }
        };

        // Get session data
        let session_id = self.tui_bridge.session_id();
        let messages = self
            .tui_bridge
            .messages
            .lock()
            .map(|guard| guard.clone())
            .unwrap_or_default();
        let total_input_tokens = self.tui_bridge.total_input_tokens();
        let total_output_tokens = self.tui_bridge.total_output_tokens();
        let model = self
            .tui_bridge
            .agent_bridge
            .lock()
            .ok()
            .map(|bridge| bridge.model().to_string());

        // Check if there are messages to share
        let user_assistant_count = messages
            .iter()
            .filter(|m| matches!(m.role, limit_llm::Role::User | limit_llm::Role::Assistant))
            .count();

        if user_assistant_count == 0 {
            let msg =
                Message::system("⚠ No messages to share. Start a conversation first.".to_string());
            self.tui_bridge.chat_view().lock().unwrap().add_message(msg);
            return Ok(());
        }

        // Export based on format
        if format_str.is_empty() || format_str == "clipboard" || format_str == "cb" {
            // Copy to clipboard
            match SessionShare::generate_share_content(
                &session_id,
                &messages,
                total_input_tokens,
                total_output_tokens,
                model.clone(),
                format,
            ) {
                Ok(content) => {
                    if let Some(ref clipboard) = self.clipboard {
                        match clipboard.set_text(&content) {
                            Ok(()) => {
                                let short_id = &session_id[..session_id.len().min(8)];
                                let msg = Message::system(format!(
                                    "✓ Session {} copied to clipboard ({} messages, {} tokens)",
                                    short_id,
                                    user_assistant_count,
                                    total_input_tokens + total_output_tokens
                                ));
                                self.tui_bridge.chat_view().lock().unwrap().add_message(msg);
                            }
                            Err(e) => {
                                let msg = Message::system(format!(
                                    "❌ Failed to copy to clipboard: {}",
                                    e
                                ));
                                self.tui_bridge.chat_view().lock().unwrap().add_message(msg);
                            }
                        }
                    } else {
                        let msg = Message::system(
                            "❌ Clipboard not available. Try '/share md' to save as file."
                                .to_string(),
                        );
                        self.tui_bridge.chat_view().lock().unwrap().add_message(msg);
                    }
                }
                Err(e) => {
                    let msg =
                        Message::system(format!("❌ Failed to generate share content: {}", e));
                    self.tui_bridge.chat_view().lock().unwrap().add_message(msg);
                }
            }
        } else {
            // Save to file
            match SessionShare::export_session(
                &session_id,
                &messages,
                total_input_tokens,
                total_output_tokens,
                model,
                format,
            ) {
                Ok((filepath, export)) => {
                    let short_id = &session_id[..session_id.len().min(8)];
                    let extension = match format {
                        ExportFormat::Markdown => "md",
                        ExportFormat::Json => "json",
                    };
                    let msg = Message::system(format!(
                        "✓ Session {} exported to {}\n  ({} messages, {} tokens)\n  Location: ~/.limit/exports/",
                        short_id,
                        extension,
                        user_assistant_count,
                        total_input_tokens + total_output_tokens
                    ));
                    self.tui_bridge.chat_view().lock().unwrap().add_message(msg);

                    tracing::info!(
                        "Session exported to {:?} ({} messages)",
                        filepath,
                        export.messages.len()
                    );
                }
                Err(e) => {
                    let msg = Message::system(format!("❌ Failed to export session: {}", e));
                    self.tui_bridge.chat_view().lock().unwrap().add_message(msg);
                }
            }
        }

        Ok(())
    }

    fn prev_char_pos(&self) -> usize {
        if self.cursor_pos == 0 {
            return 0;
        }
        // Start ONE position before cursor, then find char boundary
        let mut pos = self.cursor_pos - 1;
        while pos > 0 && !self.input_text.is_char_boundary(pos) {
            pos -= 1;
        }
        pos
    }

    fn next_char_pos(&self) -> usize {
        if self.cursor_pos >= self.input_text.len() {
            return self.input_text.len();
        }
        // Start ONE position after cursor, then find char boundary
        let mut pos = self.cursor_pos + 1;
        while pos < self.input_text.len() && !self.input_text.is_char_boundary(pos) {
            pos += 1;
        }
        pos
    }

    fn draw(&mut self) -> Result<(), CliError> {
        let chat_view = self.tui_bridge.chat_view().clone();
        let state = self.tui_bridge.state();
        let input_text = self.input_text.clone();
        let cursor_pos = self.cursor_pos;
        let status_message = self.status_message.clone();
        let status_is_error = self.status_is_error;
        let cursor_blink_state = self.cursor_blink_state;
        let tui_bridge = &self.tui_bridge;
        let file_autocomplete = self.file_autocomplete.clone();

        self.terminal
            .draw(|f| {
                Self::draw_ui(
                    f,
                    &chat_view,
                    state,
                    &input_text,
                    cursor_pos,
                    &status_message,
                    status_is_error,
                    cursor_blink_state,
                    tui_bridge,
                    &file_autocomplete,
                );
            })
            .map_err(|e| CliError::IoError(io::Error::other(e)))?;

        Ok(())
    }

    /// Draw the TUI interface
    #[allow(clippy::too_many_arguments)]
    fn draw_ui(
        f: &mut Frame,
        chat_view: &Arc<Mutex<ChatView>>,
        _state: TuiState,
        input_text: &str,
        cursor_pos: usize,
        status_message: &str,
        status_is_error: bool,
        cursor_blink_state: bool,
        tui_bridge: &TuiBridge,
        file_autocomplete: &Option<FileAutocompleteState>,
    ) {
        let size = f.area();

        // Check if we have activities to show
        let activity_count = tui_bridge.activity_feed().lock().unwrap().len();
        let activity_height = if activity_count > 0 {
            (activity_count as u16).min(3) // Max 3 lines for activity feed
        } else {
            0
        };

        // Build constraints based on whether we have activities
        let constraints: Vec<Constraint> = vec![Constraint::Percentage(90)]; // Chat view
        let mut constraints = constraints;
        if activity_height > 0 {
            constraints.push(Constraint::Length(activity_height)); // Activity feed
        }
        constraints.push(Constraint::Length(1)); // Status bar
        constraints.push(Constraint::Length(6)); // Input area

        // Split the screen
        let chunks = Layout::default()
            .direction(Direction::Vertical)
            .constraints(constraints.as_slice())
            .split(size);

        let mut chunk_idx = 0;

        // Draw chat view with border
        {
            let chat = chat_view.lock().unwrap();
            let total_input = tui_bridge.total_input_tokens();
            let total_output = tui_bridge.total_output_tokens();
            let title = format!(" Chat (↑{} ↓{}) ", total_input, total_output);
            let chat_block = Block::default()
                .borders(Borders::ALL)
                .title(title)
                .title_style(
                    Style::default()
                        .fg(Color::Cyan)
                        .add_modifier(Modifier::BOLD),
                );
            f.render_widget(&*chat, chat_block.inner(chunks[chunk_idx]));
            f.render_widget(chat_block, chunks[chunk_idx]);
            chunk_idx += 1;
        }

        // Draw activity feed if present
        if activity_height > 0 {
            let activity_feed = tui_bridge.activity_feed().lock().unwrap();
            let activity_block = Block::default()
                .borders(Borders::NONE)
                .style(Style::default().bg(Color::Reset));
            let activity_inner = activity_block.inner(chunks[chunk_idx]);
            f.render_widget(activity_block, chunks[chunk_idx]);
            activity_feed.render(activity_inner, f.buffer_mut());
            chunk_idx += 1;
        }

        // Draw status bar
        {
            let status_style = if status_is_error {
                Style::default().fg(Color::Red).bg(Color::Reset)
            } else {
                Style::default().fg(Color::Yellow)
            };

            let status = Paragraph::new(Line::from(vec![
                Span::styled(" ● ", Style::default().fg(Color::Green)),
                Span::styled(status_message, status_style),
            ]));
            f.render_widget(status, chunks[chunk_idx]);
            chunk_idx += 1;
        }

        // Draw input area with border
        {
            let input_block = Block::default()
                .borders(Borders::ALL)
                .title(" Input (Esc or /exit to quit) ")
                .title_style(Style::default().fg(Color::Cyan));

            let input_inner = input_block.inner(chunks[chunk_idx]);
            f.render_widget(input_block, chunks[chunk_idx]);

            // Build input line with cursor
            let before_cursor = &input_text[..cursor_pos];
            let at_cursor = if cursor_pos < input_text.len() {
                &input_text[cursor_pos
                    ..cursor_pos
                        + input_text[cursor_pos..]
                            .chars()
                            .next()
                            .map(|c| c.len_utf8())
                            .unwrap_or(0)]
            } else {
                " "
            };
            let after_cursor = if cursor_pos < input_text.len() {
                &input_text[cursor_pos + at_cursor.len()..]
            } else {
                ""
            };

            let cursor_style = if cursor_blink_state {
                Style::default().bg(Color::White).fg(Color::Black)
            } else {
                Style::default().bg(Color::Reset).fg(Color::Reset)
            };

            let input_line = if input_text.is_empty() {
                Line::from(vec![Span::styled(
                    "Type your message here...",
                    Style::default().fg(Color::DarkGray),
                )])
            } else {
                Line::from(vec![
                    Span::raw(before_cursor),
                    Span::styled(at_cursor, cursor_style),
                    Span::raw(after_cursor),
                ])
            };

            let input_para = Paragraph::new(input_line).wrap(Wrap { trim: false });
            f.render_widget(input_para, input_inner);
        }

        // Draw file autocomplete popup if active
        if let Some(ref ac) = file_autocomplete {
            if ac.is_active && !ac.matches.is_empty() {
                // Find the input area chunk (it's the last one)
                let input_area = chunks.last().unwrap();

                // Calculate popup area above input
                let popup_area = calculate_popup_area(*input_area, ac.matches.len());

                // Create and render the autocomplete widget
                let widget = FileAutocompleteWidget::new(&ac.matches, ac.selected_index, &ac.query);
                f.render_widget(widget, popup_area);
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    /// Create a test config for AgentBridge
    fn create_test_config() -> limit_llm::Config {
        use limit_llm::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,
        }
    }

    #[test]
    fn test_tui_bridge_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();
        assert_eq!(tui_bridge.state(), TuiState::Idle);
    }

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

        let mut tui_bridge = TuiBridge::new(agent_bridge, rx).unwrap();

        let op_id = tui_bridge.operation_id();
        tx.send(AgentEvent::Thinking { operation_id: op_id }).unwrap();
        tui_bridge.process_events().unwrap();
        assert!(matches!(tui_bridge.state(), TuiState::Thinking));

        tx.send(AgentEvent::Done { operation_id: op_id }).unwrap();
        tui_bridge.process_events().unwrap();
        assert_eq!(tui_bridge.state(), TuiState::Idle);
    }

    #[test]
    fn test_tui_bridge_chat_view() {
        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();

        tui_bridge.add_user_message("Hello".to_string());
        assert_eq!(tui_bridge.chat_view().lock().unwrap().message_count(), 3); // 1 user + 2 system (welcome + model)
    }

    #[test]
    fn test_tui_state_default() {
        let state = TuiState::default();
        assert_eq!(state, TuiState::Idle);
    }
}