app.rs

use crate::permissions::PermissionMode;
use crate::question::QuestionState;
use crate::selection::TextSelection;
use crate::views::tool_call::{ContentSegment, ToolCallDisplay, ToolResultDisplay, ToolStatus};
use crate::widgets::ToastManager;
use cortex_core::{
    animation::{Pulse, Spinner, Typewriter},
    widgets::{CortexInput, Message},
};
use std::collections::VecDeque;
use std::time::{Duration, Instant};
use uuid::Uuid;

/// The current view/screen being displayed
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum AppView {
    #[default]
    Session,
    Approval,
    Questions,
    Settings,
    Help,
}

/// Which UI element currently has focus
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum FocusTarget {
    #[default]
    Input,
    Chat,
    Sidebar,
    Modal,
}

/// State for streaming responses
#[derive(Debug, Clone, Default)]
pub struct StreamingState {
    pub is_streaming: bool,
    pub current_tool: Option<String>,
    pub tool_status: Option<String>,
    pub thinking: bool,
    /// When the current task started (for elapsed time display)
    pub task_started_at: Option<Instant>,
    /// Name of the tool currently executing in background (for visual indicator)
    pub executing_tool: Option<String>,
    /// When the tool started executing (for elapsed time display)
    pub tool_started_at: Option<Instant>,
}

impl StreamingState {
    pub fn start(&mut self, tool: Option<String>) {
        self.is_streaming = true;
        self.thinking = true;
        self.current_tool = tool;
        self.task_started_at = Some(Instant::now());
    }

    /// Get the elapsed seconds since the task started
    pub fn elapsed_seconds(&self) -> u64 {
        self.task_started_at
            .map(|t| t.elapsed().as_secs())
            .unwrap_or(0)
    }

    /// Reset streaming state when task completes
    pub fn stop(&mut self) {
        self.is_streaming = false;
        self.thinking = false;
        self.current_tool = None;
        self.tool_status = None;
        self.task_started_at = None;
    }

    /// Start tool execution in background
    pub fn start_tool_execution(&mut self, tool_name: String) {
        self.executing_tool = Some(tool_name);
        self.tool_started_at = Some(Instant::now());
    }

    /// Clear tool execution state
    pub fn stop_tool_execution(&mut self) {
        self.executing_tool = None;
        self.tool_started_at = None;
    }

    /// Check if a tool is currently executing
    pub fn is_tool_executing(&self) -> bool {
        self.executing_tool.is_some()
    }

    /// Get the elapsed seconds since tool started executing
    pub fn tool_elapsed_seconds(&self) -> u64 {
        self.tool_started_at
            .map(|t| t.elapsed().as_secs())
            .unwrap_or(0)
    }
}

/// Mode for tool approval
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ApprovalMode {
    #[default]
    Ask,
    AllowSession,
    AllowAlways,
}

/// State for pending tool approval
#[derive(Debug, Clone, Default)]
pub struct ApprovalState {
    /// Unique ID for this tool call (from the LLM)
    pub tool_call_id: String,
    pub tool_name: String,
    pub tool_args: String,
    /// Parsed arguments for execution
    pub tool_args_json: Option<serde_json::Value>,
    pub diff_preview: Option<String>,
    pub approval_mode: ApprovalMode,
}

impl ApprovalState {
    /// Creates a new ApprovalState with the given tool name and arguments.
    pub fn new(tool_name: String, tool_args: serde_json::Value) -> Self {
        Self {
            tool_call_id: String::new(),
            tool_name,
            tool_args: serde_json::to_string_pretty(&tool_args).unwrap_or_default(),
            tool_args_json: Some(tool_args),
            diff_preview: None,
            approval_mode: ApprovalMode::default(),
        }
    }

    /// Creates an ApprovalState with a specific tool call ID.
    pub fn with_id(mut self, id: impl Into<String>) -> Self {
        self.tool_call_id = id.into();
        self
    }

    /// Adds a diff preview to the approval state.
    pub fn with_diff(mut self, diff: String) -> Self {
        self.diff_preview = Some(diff);
        self
    }
}

/// State for a pending tool execution waiting for continuation
#[derive(Debug, Clone)]
pub struct PendingToolResult {
    /// Tool call ID from the LLM
    pub tool_call_id: String,
    /// Tool name
    pub tool_name: String,
    /// Tool output/result
    pub output: String,
    /// Whether the tool succeeded
    pub success: bool,
}

// ============================================================================
// SUBAGENT TASK DISPLAY
// ============================================================================

/// Display state for an active subagent task.
#[derive(Debug, Clone)]
pub struct SubagentTaskDisplay {
    /// Subagent session ID.
    pub session_id: String,
    /// Original tool call ID (for matching response).
    pub tool_call_id: String,
    /// Task description.
    pub description: String,
    /// Subagent type (code, research, etc.).
    pub agent_type: String,
    /// Current status.
    pub status: SubagentDisplayStatus,
    /// Spinner frame (0-3 for animation).
    pub spinner_frame: usize,
    /// Current activity description.
    pub current_activity: String,
    /// Tool calls made by this subagent: (name, success).
    pub tool_calls: Vec<(String, bool)>,
    /// Last output preview (first 200 chars).
    pub output_preview: String,
    /// Start time.
    pub started_at: Instant,
}

impl SubagentTaskDisplay {
    /// Create a new subagent task display.
    pub fn new(
        session_id: impl Into<String>,
        tool_call_id: impl Into<String>,
        description: impl Into<String>,
        agent_type: impl Into<String>,
    ) -> Self {
        Self {
            session_id: session_id.into(),
            tool_call_id: tool_call_id.into(),
            description: description.into(),
            agent_type: agent_type.into(),
            status: SubagentDisplayStatus::Starting,
            spinner_frame: 0,
            current_activity: "Initializing...".to_string(),
            tool_calls: Vec::new(),
            output_preview: String::new(),
            started_at: Instant::now(),
        }
    }

    /// Get elapsed time since start.
    pub fn elapsed(&self) -> Duration {
        self.started_at.elapsed()
    }
}

/// Status of a subagent task for display.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SubagentDisplayStatus {
    /// Subagent is initializing.
    Starting,
    /// Subagent is thinking/generating.
    Thinking,
    /// Subagent is executing a tool.
    ExecutingTool(String),
    /// Subagent completed successfully.
    Completed,
    /// Subagent failed.
    Failed,
}

impl SubagentDisplayStatus {
    /// Get a short description of the status.
    pub fn description(&self) -> String {
        match self {
            Self::Starting => "Starting...".to_string(),
            Self::Thinking => "Thinking...".to_string(),
            Self::ExecutingTool(name) => format!("Running {}", name),
            Self::Completed => "Completed".to_string(),
            Self::Failed => "Failed".to_string(),
        }
    }

    /// Check if this is a terminal status.
    pub fn is_terminal(&self) -> bool {
        matches!(self, Self::Completed | Self::Failed)
    }
}

/// Trigger type for autocomplete
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AutocompleteTrigger {
    Command,
    Mention,
}

/// An item in the autocomplete list
#[derive(Debug, Clone)]
pub struct AutocompleteItem {
    pub value: String,
    pub label: String,
    pub description: String,
    pub icon: char,
    pub category: String,
}

impl AutocompleteItem {
    pub fn new(
        value: impl Into<String>,
        label: impl Into<String>,
        description: impl Into<String>,
    ) -> Self {
        Self {
            value: value.into(),
            label: label.into(),
            description: description.into(),
            icon: ' ',
            category: String::new(),
        }
    }

    pub fn with_icon(mut self, icon: char) -> Self {
        self.icon = icon;
        self
    }

    pub fn with_category(mut self, category: impl Into<String>) -> Self {
        self.category = category.into();
        self
    }
}

/// State for the autocomplete popup
#[derive(Debug, Clone, Default)]
pub struct AutocompleteState {
    pub visible: bool,
    pub trigger: Option<AutocompleteTrigger>,
    pub query: String,
    pub trigger_position: usize,
    pub items: Vec<AutocompleteItem>,
    pub selected: usize,
    pub max_visible: usize,
    pub scroll_offset: usize,
}

impl AutocompleteState {
    pub fn new() -> Self {
        Self {
            visible: false,
            trigger: None,
            query: String::new(),
            trigger_position: 0,
            items: Vec::new(),
            selected: 0,
            max_visible: 8,
            scroll_offset: 0,
        }
    }

    /// Select the previous item in the list
    pub fn select_prev(&mut self) {
        if self.items.is_empty() {
            return;
        }
        if self.selected == 0 {
            // Wrap to end
            self.selected = self.items.len() - 1;
            // Scroll to show the last items
            if self.items.len() > self.max_visible {
                self.scroll_offset = self.items.len() - self.max_visible;
            }
        } else {
            self.selected -= 1;
            // Adjust scroll offset to keep selected item visible
            if self.selected < self.scroll_offset {
                self.scroll_offset = self.selected;
            }
        }
    }

    /// Select the next item in the list
    pub fn select_next(&mut self) {
        if self.items.is_empty() {
            return;
        }
        self.selected = (self.selected + 1) % self.items.len();
        // Adjust scroll offset to keep selected item visible
        if self.selected == 0 {
            // Wrapped around to start
            self.scroll_offset = 0;
        } else if self.selected >= self.scroll_offset + self.max_visible {
            self.scroll_offset = self.selected - self.max_visible + 1;
        }
    }

    /// Get the completion text for the currently selected item
    pub fn completion_text(&self) -> Option<&str> {
        self.items
            .get(self.selected)
            .map(|item| item.value.as_str())
    }

    /// Hide the autocomplete popup and reset state
    pub fn hide(&mut self) {
        self.visible = false;
        self.items.clear();
        self.selected = 0;
        self.scroll_offset = 0;
        self.query.clear();
        self.trigger = None;
    }

    /// Check if there are any items in the list
    pub fn has_items(&self) -> bool {
        !self.items.is_empty()
    }

    /// Get the currently visible items based on scroll offset
    pub fn visible_items(&self) -> &[AutocompleteItem] {
        let start = self.scroll_offset;
        let end = (start + self.max_visible).min(self.items.len());
        &self.items[start..end]
    }

    /// Show the autocomplete popup with a trigger
    pub fn show(&mut self, trigger: AutocompleteTrigger, position: usize) {
        self.visible = true;
        self.trigger = Some(trigger);
        self.trigger_position = position;
        self.query.clear();
        self.selected = 0;
        self.scroll_offset = 0;
    }

    /// Set the filter query
    pub fn set_query(&mut self, query: &str) {
        self.query = query.to_string();
        self.selected = 0;
        self.scroll_offset = 0;
    }

    /// Set the list of items
    pub fn set_items(&mut self, items: Vec<AutocompleteItem>) {
        self.items = items;
        self.selected = 0;
        self.scroll_offset = 0;
    }
}

/// Summary of a session for the sidebar
#[derive(Debug, Clone)]
pub struct SessionSummary {
    pub id: Uuid,
    pub title: String,
    pub last_message: String,
    pub timestamp: chrono::DateTime<chrono::Utc>,
    pub message_count: usize,
}

impl SessionSummary {
    /// Create a new session summary with minimal info
    pub fn new(id: Uuid, title: String) -> Self {
        Self {
            id,
            title,
            last_message: String::new(),
            timestamp: chrono::Utc::now(),
            message_count: 0,
        }
    }

    /// Get a human-readable relative time string
    pub fn relative_time(&self) -> String {
        cortex_protocol::num_format::format_relative_time_compact(self.timestamp)
    }

    pub fn with_message_count(mut self, count: usize) -> Self {
        self.message_count = count;
        self
    }

    pub fn with_timestamp(mut self, timestamp: chrono::DateTime<chrono::Utc>) -> Self {
        self.timestamp = timestamp;
        self
    }

    /// Sets the last message preview.
    pub fn with_last_message(mut self, message: impl Into<String>) -> Self {
        self.last_message = message.into();
        self
    }
}

/// Currently active modal dialog
#[derive(Debug, Clone)]
pub enum ActiveModal {
    Form(crate::widgets::FormState),
    ProviderPicker,
    ModelPicker,
    CommandPalette,
    Export,
    Fork,
}

/// Main application state
pub struct AppState {
    pub view: AppView,
    pub previous_view: Option<AppView>,
    pub focus: FocusTarget,
    pub session_id: Option<Uuid>,
    pub messages: Vec<Message>,
    pub model: String,
    pub provider: String,
    pub system_prompt: Option<String>,
    pub sidebar_visible: bool,
    pub sidebar_width: u16,
    pub chat_scroll: usize,
    pub sidebar_scroll: usize,
    pub scrollbar_visible_until: Option<Instant>,
    pub chat_scroll_pinned_bottom: bool,
    pub input: CortexInput<'static>,
    pub autocomplete: AutocompleteState,
    pub streaming: StreamingState,
    pub typewriter: Option<Typewriter>,
    pub brain_pulse: Pulse,
    pub spinner: Spinner,
    pub brain_frame: u64,
    pub pending_approval: Option<ApprovalState>,
    pub session_history: Vec<SessionSummary>,
    pub terminal_size: (u16, u16),
    pub running: bool,
    pub last_ctrl_c: Option<Instant>,
    pub active_modal: Option<ActiveModal>,
    pub provider_picker: crate::widgets::ProviderPickerState,
    pub model_picker: crate::widgets::ModelPickerState,
    pub text_selection: TextSelection,
    pub toasts: ToastManager,
    /// Current permission mode for tool execution
    pub permission_mode: PermissionMode,
    /// Tool calls being displayed
    pub tool_calls: Vec<ToolCallDisplay>,
    /// Pending tool results that need to be sent back to the LLM
    pub pending_tool_results: Vec<PendingToolResult>,
    /// Current thinking budget level (for models that support it)
    pub thinking_budget: Option<String>,
    /// Event sequence counter for ordering tool calls by arrival
    pub event_sequence: u64,
    /// Content segments for interleaved text/tool display during streaming
    pub content_segments: Vec<ContentSegment>,
    /// Accumulated text before the next tool call (for segment creation)
    pub pending_text_segment: String,
    /// Active question prompt state
    pub question_state: Option<QuestionState>,
    /// Hovered option in question prompt (for mouse support)
    pub question_hovered_option: Option<usize>,
    /// Hovered tab in question prompt (for mouse support)
    pub question_hovered_tab: Option<usize>,
    /// Queue of pending user messages (sent together when system becomes available)
    pub message_queue: VecDeque<String>,
    /// Active subagent tasks being displayed.
    pub active_subagents: Vec<SubagentTaskDisplay>,
    /// MCP servers list for management
    pub mcp_servers: Vec<crate::modal::mcp_manager::McpServerInfo>,
    /// Context files added to the session
    pub context_files: Vec<std::path::PathBuf>,
    /// Current log level setting
    pub log_level: String,
    /// Generic settings storage
    pub settings: std::collections::HashMap<String, String>,
    /// Diff scroll position for approval view
    pub diff_scroll: i32,
    /// Input mode (normal text input or interactive selection)
    pub input_mode: crate::interactive::InputMode,
    /// Compact display mode
    pub compact_mode: bool,
    /// Debug mode enabled
    pub debug_mode: bool,
    /// Sandbox mode (restricted execution)
    pub sandbox_mode: bool,
    /// Temperature for model sampling
    pub temperature: f32,
    /// Max tokens for model output
    pub max_tokens: Option<u32>,
    /// Command history for /history
    pub command_history: Vec<String>,
    // Extended settings
    /// Show timestamps on messages
    pub timestamps_enabled: bool,
    /// Show line numbers in code blocks
    pub line_numbers_enabled: bool,
    /// Word wrap enabled
    pub word_wrap_enabled: bool,
    /// Syntax highlighting enabled
    pub syntax_highlight_enabled: bool,
    /// Auto scroll to new messages
    pub auto_scroll_enabled: bool,
    /// Sound notifications enabled
    pub sound_enabled: bool,
    /// Context-aware mode (include open files)
    pub context_aware_enabled: bool,
    /// Add as co-author on commits
    pub co_author_enabled: bool,
    /// Auto-suggest commits after changes
    pub auto_commit_enabled: bool,
    /// Sign commits with GPG
    pub sign_commits_enabled: bool,
    /// Cloud sync for sessions
    pub cloud_sync_enabled: bool,
    /// Auto-save sessions
    pub auto_save_enabled: bool,
    /// Keep session history
    pub session_history_enabled: bool,
    /// Telemetry enabled
    pub telemetry_enabled: bool,
    /// Analytics enabled
    pub analytics_enabled: bool,
}

impl AppState {
    /// Create a new AppState with default values
    pub fn new() -> Self {
        Self {
            view: AppView::default(),
            previous_view: None,
            focus: FocusTarget::default(),
            session_id: None,
            messages: Vec::new(),
            model: String::from("gpt-4"),
            provider: String::from("openai"),
            system_prompt: None,
            sidebar_visible: true,
            sidebar_width: 30,
            chat_scroll: 0,
            sidebar_scroll: 0,
            scrollbar_visible_until: None,
            chat_scroll_pinned_bottom: true,
            input: CortexInput::new(),
            autocomplete: AutocompleteState::new(),
            streaming: StreamingState::default(),
            typewriter: None,
            brain_pulse: Pulse::new(2000),
            spinner: Spinner::dots(),
            brain_frame: 0,
            pending_approval: None,
            session_history: Vec::new(),
            terminal_size: (80, 24),
            running: true,
            last_ctrl_c: None,
            active_modal: None,
            provider_picker: crate::widgets::ProviderPickerState::new(),
            model_picker: crate::widgets::ModelPickerState::new(),
            text_selection: TextSelection::new(),
            toasts: ToastManager::new(),
            permission_mode: PermissionMode::default(),
            tool_calls: Vec::new(),
            pending_tool_results: Vec::new(),
            thinking_budget: None,
            event_sequence: 0,
            content_segments: Vec::new(),
            pending_text_segment: String::new(),
            question_state: None,
            question_hovered_option: None,
            question_hovered_tab: None,
            message_queue: VecDeque::new(),
            active_subagents: Vec::new(),
            mcp_servers: Vec::new(),
            context_files: Vec::new(),
            log_level: String::from("info"),
            settings: std::collections::HashMap::new(),
            diff_scroll: 0,
            input_mode: crate::interactive::InputMode::Normal,
            compact_mode: false,
            debug_mode: false,
            sandbox_mode: false,
            temperature: 0.7,
            max_tokens: None,
            command_history: Vec::new(),
            // Extended settings with sensible defaults
            timestamps_enabled: false,
            line_numbers_enabled: true,
            word_wrap_enabled: true,
            syntax_highlight_enabled: true,
            auto_scroll_enabled: true,
            sound_enabled: false,
            context_aware_enabled: true,
            co_author_enabled: true,
            auto_commit_enabled: false,
            sign_commits_enabled: false,
            cloud_sync_enabled: false,
            auto_save_enabled: true,
            session_history_enabled: true,
            telemetry_enabled: false,
            analytics_enabled: false,
        }
    }

    /// Create AppState with a specific model
    pub fn with_model(mut self, model: impl Into<String>) -> Self {
        self.model = model.into();
        self
    }

    /// Create AppState with a specific provider
    pub fn with_provider(mut self, provider: impl Into<String>) -> Self {
        self.provider = provider.into();
        self
    }

    /// Create AppState with a system prompt
    pub fn with_system_prompt(mut self, prompt: impl Into<String>) -> Self {
        self.system_prompt = Some(prompt.into());
        self
    }

    /// Create AppState with terminal size
    pub fn with_terminal_size(mut self, width: u16, height: u16) -> Self {
        self.terminal_size = (width, height);
        self
    }

    /// Set the current view
    pub fn set_view(&mut self, view: AppView) {
        self.previous_view = Some(self.view);
        self.view = view;
    }

    /// Go back to the previous view
    pub fn go_back(&mut self) {
        if let Some(prev) = self.previous_view.take() {
            self.view = prev;
        }
    }

    /// Add a message to the chat
    pub fn add_message(&mut self, message: Message) {
        self.messages.push(message);
        if self.chat_scroll_pinned_bottom {
            self.scroll_chat_to_bottom();
        }
    }

    /// Start streaming a response
    pub fn start_streaming(&mut self, tool: Option<String>) {
        self.streaming.start(tool);
        // Use dynamic typewriter that adapts to stream speed
        self.typewriter = Some(Typewriter::dynamic(String::new(), 500.0));
    }

    /// Stop streaming
    pub fn stop_streaming(&mut self) {
        self.streaming.stop();
    }

    /// Append content to the last streaming message
    pub fn append_streaming_content(&mut self, content: &str) {
        if let Some(msg) = self.messages.last_mut() {
            msg.content.push_str(content);
        }
        self.streaming.thinking = false;
    }

    /// Get the last message
    pub fn last_message(&self) -> Option<&Message> {
        self.messages.last()
    }

    /// Get mutable reference to the last message
    pub fn last_message_mut(&mut self) -> Option<&mut Message> {
        self.messages.last_mut()
    }

    /// Clear all messages
    pub fn clear_messages(&mut self) {
        self.messages.clear();
        self.chat_scroll = 0;
    }

    /// Set the focus target
    pub fn set_focus(&mut self, focus: FocusTarget) {
        self.focus = focus;
    }

    /// Move focus to the next element
    pub fn focus_next(&mut self) {
        self.focus = match self.focus {
            FocusTarget::Input => FocusTarget::Chat,
            FocusTarget::Chat => {
                if self.sidebar_visible {
                    FocusTarget::Sidebar
                } else {
                    FocusTarget::Input
                }
            }
            FocusTarget::Sidebar => FocusTarget::Input,
            FocusTarget::Modal => FocusTarget::Modal,
        };
    }

    /// Move focus to the previous element
    pub fn focus_prev(&mut self) {
        self.focus = match self.focus {
            FocusTarget::Input => {
                if self.sidebar_visible {
                    FocusTarget::Sidebar
                } else {
                    FocusTarget::Chat
                }
            }
            FocusTarget::Chat => FocusTarget::Input,
            FocusTarget::Sidebar => FocusTarget::Chat,
            FocusTarget::Modal => FocusTarget::Modal,
        };
    }

    /// Scroll the chat by a delta amount
    pub fn scroll_chat(&mut self, delta: i32) {
        if delta < 0 {
            self.chat_scroll = self
                .chat_scroll
                .saturating_sub(delta.unsigned_abs() as usize);
        } else {
            self.chat_scroll = self.chat_scroll.saturating_add(delta as usize);
        }
        self.chat_scroll_pinned_bottom = false;
        self.show_scrollbar();
    }

    /// Scroll to the bottom of the chat
    pub fn scroll_chat_to_bottom(&mut self) {
        self.chat_scroll = 0; // 0 = at bottom (showing newest messages)
        self.chat_scroll_pinned_bottom = true;
        self.show_scrollbar();
    }

    /// Scroll to the top of the chat
    pub fn scroll_chat_to_top(&mut self) {
        self.chat_scroll = usize::MAX; // Large value = scrolled up (showing oldest messages)
        self.chat_scroll_pinned_bottom = false;
        self.show_scrollbar();
    }

    /// Check if chat is scrolled to the bottom
    pub fn is_chat_at_bottom(&self) -> bool {
        self.chat_scroll_pinned_bottom
    }

    /// Show the scrollbar temporarily
    pub fn show_scrollbar(&mut self) {
        self.scrollbar_visible_until = Some(Instant::now() + Duration::from_secs(2));
    }

    /// Check if the scrollbar should be visible
    pub fn is_scrollbar_visible(&self) -> bool {
        self.scrollbar_visible_until
            .map(|until| Instant::now() < until)
            .unwrap_or(false)
    }

    /// Get the scrollbar opacity (for fade effect)
    pub fn scrollbar_opacity(&self) -> f32 {
        self.scrollbar_visible_until
            .map(|until| {
                let remaining = until.saturating_duration_since(Instant::now());
                let fade_start = Duration::from_millis(500);
                if remaining > fade_start {
                    1.0
                } else {
                    remaining.as_secs_f32() / fade_start.as_secs_f32()
                }
            })
            .unwrap_or(0.0)
    }

    /// Tick the scrollbar visibility timer
    pub fn tick_scrollbar(&mut self) {
        if let Some(until) = self.scrollbar_visible_until
            && Instant::now() >= until
        {
            self.scrollbar_visible_until = None;
        }
    }

    /// Scroll the sidebar
    pub fn scroll_sidebar(&mut self, delta: i32) {
        if delta < 0 {
            self.sidebar_scroll = self
                .sidebar_scroll
                .saturating_sub(delta.unsigned_abs() as usize);
        } else {
            self.sidebar_scroll = self.sidebar_scroll.saturating_add(delta as usize);
        }
    }

    /// Toggle sidebar visibility
    pub fn toggle_sidebar(&mut self) {
        self.sidebar_visible = !self.sidebar_visible;
        if !self.sidebar_visible && self.focus == FocusTarget::Sidebar {
            self.focus = FocusTarget::Input;
        }
    }

    /// Request approval for a tool
    pub fn request_approval(
        &mut self,
        tool_name: String,
        tool_args: String,
        diff_preview: Option<String>,
    ) {
        // Try to parse the args as JSON
        let tool_args_json = serde_json::from_str(&tool_args).ok();
        self.pending_approval = Some(ApprovalState {
            tool_call_id: String::new(),
            tool_name,
            tool_args,
            tool_args_json,
            diff_preview,
            approval_mode: ApprovalMode::Ask,
        });
        self.set_view(AppView::Approval);
    }

    /// Request approval for a tool with full details
    pub fn request_tool_approval(
        &mut self,
        tool_call_id: String,
        tool_name: String,
        tool_args: serde_json::Value,
        diff_preview: Option<String>,
    ) {
        self.pending_approval = Some(ApprovalState {
            tool_call_id,
            tool_name,
            tool_args: serde_json::to_string_pretty(&tool_args).unwrap_or_default(),
            tool_args_json: Some(tool_args),
            diff_preview,
            approval_mode: ApprovalMode::Ask,
        });
        self.set_view(AppView::Approval);
    }

    /// Approve the pending tool
    pub fn approve(&mut self) -> Option<ApprovalState> {
        let approval = self.pending_approval.take();
        self.go_back();
        approval
    }

    /// Reject the pending tool
    pub fn reject(&mut self) -> Option<ApprovalState> {
        let approval = self.pending_approval.take();
        self.go_back();
        approval
    }

    /// Check if there's a pending approval
    pub fn has_pending_approval(&self) -> bool {
        self.pending_approval.is_some()
    }

    /// Start a new session
    pub fn new_session(&mut self) {
        self.session_id = Some(Uuid::new_v4());
        self.clear_messages();
        self.set_view(AppView::Session);
    }

    /// Load an existing session
    pub fn load_session(&mut self, session_id: Uuid) {
        self.session_id = Some(session_id);
        self.set_view(AppView::Session);
    }

    /// Tick animations and timers
    pub fn tick(&mut self) {
        self.brain_pulse.tick();
        self.spinner.tick();
        self.brain_frame = self.brain_frame.wrapping_add(1);
        self.tick_scrollbar();

        if let Some(ref mut typewriter) = self.typewriter {
            typewriter.tick();
        }
    }

    /// Check if currently streaming
    pub fn is_streaming(&self) -> bool {
        self.streaming.is_streaming
    }

    /// Check if the system is busy (streaming, executing tool, has pending tool results, or running subagents)
    /// Used to determine if new messages should be queued
    pub fn is_busy(&self) -> bool {
        self.streaming.is_streaming
            || self.streaming.is_tool_executing()
            || !self.pending_tool_results.is_empty()
            || self.has_active_subagents()
    }

    /// Add a message to the queue
    pub fn queue_message(&mut self, message: String) {
        if !message.trim().is_empty() {
            self.message_queue.push_back(message);
        }
    }

    /// Get number of queued messages
    pub fn queued_count(&self) -> usize {
        self.message_queue.len()
    }

    /// Check if there are queued messages
    pub fn has_queued_messages(&self) -> bool {
        !self.message_queue.is_empty()
    }

    /// Take all queued messages and combine into one
    /// Messages are joined with double newlines
    pub fn take_queued_messages(&mut self) -> Option<String> {
        if self.message_queue.is_empty() {
            return None;
        }
        let messages: Vec<String> = self.message_queue.drain(..).collect();
        Some(messages.join("\n\n"))
    }

    /// Clear the message queue (for cancellation)
    pub fn clear_message_queue(&mut self) {
        self.message_queue.clear();
    }

    /// Get the display name for the current model
    pub fn model_display(&self) -> String {
        format!("{}/{}", self.provider, self.model)
    }

    /// Set the terminal size
    pub fn set_terminal_size(&mut self, width: u16, height: u16) {
        self.terminal_size = (width, height);
    }

    /// Request to quit the application
    pub fn quit(&mut self) {
        self.running = false;
    }

    /// Handle Ctrl+C press (double-tap to quit)
    pub fn handle_ctrl_c(&mut self) -> bool {
        let now = Instant::now();
        if let Some(last) = self.last_ctrl_c
            && now.duration_since(last) < Duration::from_millis(500)
        {
            self.quit();
            return true;
        }
        self.last_ctrl_c = Some(now);
        false
    }

    /// Reset the Ctrl+C timer
    pub fn reset_ctrl_c(&mut self) {
        self.last_ctrl_c = None;
    }

    /// Open the provider picker modal
    pub fn open_provider_picker(&mut self) {
        self.provider_picker.load_providers(&self.provider);
        self.active_modal = Some(ActiveModal::ProviderPicker);
        self.focus = FocusTarget::Modal;
    }

    /// Open the model picker modal
    pub fn open_model_picker(&mut self) {
        self.model_picker.load_models(&self.provider, &self.model);
        self.active_modal = Some(ActiveModal::ModelPicker);
        self.focus = FocusTarget::Modal;
    }

    /// Open a modal
    pub fn open_modal(&mut self, modal: ActiveModal) {
        self.active_modal = Some(modal);
        self.focus = FocusTarget::Modal;
    }

    /// Close the current modal
    pub fn close_modal(&mut self) {
        self.active_modal = None;
        self.focus = FocusTarget::Input;
    }

    /// Check if a modal is open
    pub fn has_modal(&self) -> bool {
        self.active_modal.is_some()
    }

    /// Get the current modal
    pub fn modal(&self) -> Option<&ActiveModal> {
        self.active_modal.as_ref()
    }

    /// Cycle to the next permission mode
    pub fn cycle_permission_mode(&mut self) {
        self.permission_mode = self.permission_mode.cycle_next();
    }

    /// Set the thinking budget level
    pub fn set_thinking_budget(&mut self, budget: Option<String>) {
        self.thinking_budget = budget;
    }

    /// Add a tool call for display
    /// This also flushes any pending text as a segment before the tool call
    pub fn add_tool_call(&mut self, id: String, name: String, arguments: serde_json::Value) {
        // First, flush any accumulated text as a segment
        if !self.pending_text_segment.is_empty() {
            let text_seq = self.event_sequence;
            self.event_sequence += 1;
            self.content_segments.push(ContentSegment::Text {
                content: std::mem::take(&mut self.pending_text_segment),
                sequence: text_seq,
            });
        }

        // Now add the tool call with its sequence
        let seq = self.event_sequence;
        self.event_sequence += 1;

        // Add to content segments timeline
        self.content_segments.push(ContentSegment::ToolCall {
            tool_call_id: id.clone(),
            sequence: seq,
        });

        // Add to tool_calls for status tracking
        self.tool_calls
            .push(ToolCallDisplay::new(id, name, arguments, seq));
    }

    /// Append text to the pending segment (called during streaming)
    pub fn append_streaming_text(&mut self, text: &str) {
        self.pending_text_segment.push_str(text);
    }

    /// Flush any remaining pending text as a final segment
    pub fn flush_pending_text(&mut self) {
        if !self.pending_text_segment.is_empty() {
            let seq = self.event_sequence;
            self.event_sequence += 1;
            self.content_segments.push(ContentSegment::Text {
                content: std::mem::take(&mut self.pending_text_segment),
                sequence: seq,
            });
        }
    }

    /// Clear content segments (for new conversation turn)
    pub fn clear_content_segments(&mut self) {
        self.content_segments.clear();
        self.pending_text_segment.clear();
    }

    /// Update tool call status
    pub fn update_tool_status(&mut self, id: &str, status: ToolStatus) {
        if let Some(call) = self.tool_calls.iter_mut().find(|c| c.id == id) {
            call.set_status(status);
        }
    }

    /// Update tool call result
    pub fn update_tool_result(&mut self, id: &str, output: String, success: bool, summary: String) {
        if let Some(call) = self.tool_calls.iter_mut().find(|c| c.id == id) {
            call.set_result(ToolResultDisplay {
                output,
                success,
                summary,
            });
            call.set_status(if success {
                ToolStatus::Completed
            } else {
                ToolStatus::Failed
            });
        }
    }

    /// Toggle tool call collapsed state
    pub fn toggle_tool_collapsed(&mut self, id: &str) {
        if let Some(call) = self.tool_calls.iter_mut().find(|c| c.id == id) {
            call.toggle_collapsed();
        }
    }

    /// Clear all tool calls and content segments (for new conversation turn)
    pub fn clear_tool_calls(&mut self) {
        self.tool_calls.clear();
        self.clear_content_segments();
    }

    /// Advance spinner frames for all running tool calls
    pub fn tick_tool_spinners(&mut self) {
        for call in &mut self.tool_calls {
            if call.status == ToolStatus::Running {
                call.tick_spinner();
            }
        }
    }

    /// Append output to a tool call's live output buffer
    pub fn append_tool_output(&mut self, id: &str, line: String) {
        if let Some(call) = self.tool_calls.iter_mut().find(|c| c.id == id) {
            call.append_output(line);
        }
    }

    /// Add a pending tool result for agentic loop continuation
    pub fn add_pending_tool_result(
        &mut self,
        tool_call_id: String,
        tool_name: String,
        output: String,
        success: bool,
    ) {
        self.pending_tool_results.push(PendingToolResult {
            tool_call_id,
            tool_name,
            output,
            success,
        });
    }

    /// Take all pending tool results (clears the list)
    pub fn take_pending_tool_results(&mut self) -> Vec<PendingToolResult> {
        std::mem::take(&mut self.pending_tool_results)
    }

    /// Check if there are pending tool results
    pub fn has_pending_tool_results(&self) -> bool {
        !self.pending_tool_results.is_empty()
    }

    // ============================================================
    // SUBAGENT MANAGEMENT
    // ============================================================

    /// Add a new subagent task for display.
    pub fn add_subagent_task(&mut self, task: SubagentTaskDisplay) {
        self.active_subagents.push(task);
    }

    /// Update a subagent task's state.
    pub fn update_subagent<F>(&mut self, session_id: &str, update: F)
    where
        F: FnOnce(&mut SubagentTaskDisplay),
    {
        if let Some(task) = self
            .active_subagents
            .iter_mut()
            .find(|t| t.session_id == session_id)
        {
            update(task);
        }
    }

    /// Remove a completed/failed subagent task and return it.
    pub fn remove_subagent(&mut self, session_id: &str) -> Option<SubagentTaskDisplay> {
        if let Some(idx) = self
            .active_subagents
            .iter()
            .position(|t| t.session_id == session_id)
        {
            Some(self.active_subagents.remove(idx))
        } else {
            None
        }
    }

    /// Tick spinner frames for all active subagents.
    pub fn tick_subagent_spinners(&mut self) {
        for task in &mut self.active_subagents {
            if !task.status.is_terminal() {
                task.spinner_frame = (task.spinner_frame + 1) % 4;
            }
        }
    }

    /// Check if any subagents are currently running.
    pub fn has_active_subagents(&self) -> bool {
        self.active_subagents
            .iter()
            .any(|t| !t.status.is_terminal())
    }

    /// Get the number of active (non-terminal) subagents.
    pub fn active_subagent_count(&self) -> usize {
        self.active_subagents
            .iter()
            .filter(|t| !t.status.is_terminal())
            .count()
    }

    // ============================================================
    // QUESTION PROMPT
    // ============================================================

    /// Start a question prompt session
    pub fn start_question_prompt(&mut self, state: QuestionState) {
        self.question_state = Some(state);
        self.question_hovered_option = None;
        self.question_hovered_tab = None;
        self.view = AppView::Questions;
    }

    /// Get the current question state
    pub fn get_question_state(&self) -> Option<&QuestionState> {
        self.question_state.as_ref()
    }

    /// Get mutable question state
    pub fn get_question_state_mut(&mut self) -> Option<&mut QuestionState> {
        self.question_state.as_mut()
    }

    /// Complete the question prompt and return answers
    pub fn complete_question_prompt(&mut self) -> Option<serde_json::Value> {
        let state = self.question_state.take()?;
        self.question_hovered_option = None;
        self.question_hovered_tab = None;
        self.view = AppView::Session;
        Some(state.get_formatted_answers())
    }

    /// Cancel the question prompt
    pub fn cancel_question_prompt(&mut self) -> Option<String> {
        let state = self.question_state.take()?;
        self.question_hovered_option = None;
        self.question_hovered_tab = None;
        self.view = AppView::Session;
        Some(state.request.id)
    }

    /// Check if there's an active question prompt
    pub fn has_question_prompt(&self) -> bool {
        self.question_state.is_some()
    }

    /// Set hovered option for mouse support
    pub fn set_question_hovered_option(&mut self, index: Option<usize>) {
        self.question_hovered_option = index;
    }

    /// Set hovered tab for mouse support
    pub fn set_question_hovered_tab(&mut self, index: Option<usize>) {
        self.question_hovered_tab = index;
    }

    // ============================================================
    // INTERACTIVE INPUT MODE
    // ============================================================

    /// Check if currently in interactive mode.
    pub fn is_interactive_mode(&self) -> bool {
        self.input_mode.is_interactive()
    }

    /// Enter interactive mode with the given state.
    pub fn enter_interactive_mode(&mut self, state: crate::interactive::InteractiveState) {
        self.input_mode = crate::interactive::InputMode::Interactive(state);
    }

    /// Exit interactive mode and return to normal input.
    pub fn exit_interactive_mode(&mut self) {
        self.input_mode = crate::interactive::InputMode::Normal;
    }

    /// Get the interactive state if in interactive mode.
    pub fn get_interactive_state(&self) -> Option<&crate::interactive::InteractiveState> {
        self.input_mode.interactive()
    }

    /// Get mutable interactive state if in interactive mode.
    pub fn get_interactive_state_mut(
        &mut self,
    ) -> Option<&mut crate::interactive::InteractiveState> {
        self.input_mode.interactive_mut()
    }

    // ============================================================
    // APPROVAL MODE AND SETTINGS
    // ============================================================

    /// Returns the current approval mode as a string
    pub fn approval_mode_string(&self) -> String {
        match self.permission_mode {
            PermissionMode::High => "ask".to_string(),
            PermissionMode::Medium => "medium".to_string(),
            PermissionMode::Low => "auto".to_string(),
            PermissionMode::Yolo => "yolo".to_string(),
        }
    }

    /// Sets the approval mode
    pub fn set_approval_mode(&mut self, mode: ApprovalMode) {
        self.permission_mode = match mode {
            ApprovalMode::Ask => PermissionMode::High,
            ApprovalMode::AllowSession => PermissionMode::Medium,
            ApprovalMode::AllowAlways => PermissionMode::Yolo,
        };
    }

    /// Scroll the diff view
    pub fn scroll_diff(&mut self, delta: i32) {
        self.diff_scroll = (self.diff_scroll + delta).max(0);
    }

    // ============================================================
    // TOGGLE SETTINGS
    // ============================================================

    /// Toggle compact mode
    pub fn toggle_compact(&mut self) {
        self.compact_mode = !self.compact_mode;
    }

    /// Toggle debug mode
    pub fn toggle_debug(&mut self) {
        self.debug_mode = !self.debug_mode;
    }

    /// Toggle sandbox mode
    pub fn toggle_sandbox(&mut self) {
        self.sandbox_mode = !self.sandbox_mode;
    }

    /// Add command to history
    pub fn add_to_history(&mut self, cmd: &str) {
        if !cmd.is_empty() {
            self.command_history.push(cmd.to_string());
            // Keep only last 100 commands
            if self.command_history.len() > 100 {
                self.command_history.remove(0);
            }
        }
    }
}

impl Default for AppState {
    fn default() -> Self {
        Self::new()
    }
}