executor.rs

//! Command executor for cortex-tui slash commands.
//!
//! This module provides the `CommandExecutor` which connects parsed commands
//! to their handlers and produces `CommandResult` values.

use super::parser::CommandParser;
use super::registry::CommandRegistry;
use super::types::{CommandResult, ModalType, ParsedCommand};
use chrono::Local;

// ============================================================
// COMMAND EXECUTOR
// ============================================================

/// Executes parsed commands and returns results.
///
/// The executor connects the command registry to command handlers,
/// dispatching parsed commands to the appropriate handler functions.
pub struct CommandExecutor {
    registry: CommandRegistry,
}

impl CommandExecutor {
    /// Creates a new command executor with the default registry.
    pub fn new() -> Self {
        Self {
            registry: CommandRegistry::default(),
        }
    }

    /// Creates a command executor with a custom registry.
    pub fn with_registry(registry: CommandRegistry) -> Self {
        Self { registry }
    }

    /// Execute a parsed command.
    ///
    /// Returns a `CommandResult` indicating the action to take.
    pub fn execute(&self, cmd: &ParsedCommand) -> CommandResult {
        // Check if command exists
        if !self.registry.exists(&cmd.name) {
            return CommandResult::NotFound(format!("Unknown command: /{}", cmd.name));
        }

        // Dispatch to handler
        self.dispatch(cmd)
    }

    /// Execute a command from a raw input string.
    ///
    /// Parses the input and executes if valid.
    pub fn execute_str(&self, input: &str) -> CommandResult {
        match CommandParser::parse(input) {
            Some(cmd) => self.execute(&cmd),
            None => CommandResult::Error("Invalid command format".to_string()),
        }
    }

    /// Get the registry for completions and lookups.
    pub fn registry(&self) -> &CommandRegistry {
        &self.registry
    }
}

// ============================================================
// COMMAND DISPATCH
// ============================================================

impl CommandExecutor {
    /// Dispatch a parsed command to its handler.
    fn dispatch(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.name.as_str() {
            // ============ GENERAL ============
            "help" | "h" | "?" => self.cmd_help(cmd),
            "quit" | "q" | "exit" => CommandResult::Quit,
            "version" | "v" => self.cmd_version(),
            "upgrade" | "update" => CommandResult::OpenModal(ModalType::Upgrade),
            "settings" | "config" | "prefs" => CommandResult::OpenModal(ModalType::Settings),
            "reload-config" | "reload" => CommandResult::Async("config:reload".to_string()),
            "theme" => self.cmd_theme(cmd),
            "compact" => CommandResult::Toggle("compact".to_string()),
            "palette" | "cmd" => CommandResult::OpenModal(ModalType::CommandPalette),
            "init" => self.cmd_init(cmd),
            "commands" | "cmds" => CommandResult::Async("commands:list".to_string()),
            "agents" | "subagents" => CommandResult::OpenModal(ModalType::Agents),
            "copy" | "cp" => CommandResult::Message(
                "To copy text from Cortex:\n\n\
                 - Hold SHIFT while selecting text with mouse\n\
                 - Then use your terminal's copy (Ctrl+Shift+C or right-click)\n\n\
                 This bypasses mouse capture and uses native selection."
                    .to_string(),
            ),

            // Direct clipboard paste (#3087)
            "paste" | "pb" => CommandResult::Async("clipboard:paste".to_string()),

            // Prompt macros (#3085)
            "macro" | "macros" => self.cmd_macro(cmd),

            // Configuration validation (#3090)
            "validate-config" | "check-config" => self.cmd_validate_config(cmd),

            // External editor (#3086)
            "editor" | "edit" | "vi" => CommandResult::Async("editor:open".to_string()),

            // ============ AUTH ============
            "login" | "signin" => CommandResult::OpenModal(ModalType::Login),
            "logout" | "signout" => CommandResult::Async("auth:logout".to_string()),
            "account" | "whoami" | "me" => CommandResult::Async("auth:account".to_string()),

            // ============ BILLING ============
            "billing" | "plan" | "subscription" => {
                CommandResult::Async("billing:status".to_string())
            }
            "usage" | "stats" | "credits" => self.cmd_usage(cmd),
            "refresh" | "retry" => CommandResult::Async("billing:refresh".to_string()),

            // ============ SESSION ============
            "session" | "info" => CommandResult::Async("session:info".to_string()),
            "clear" | "cls" => CommandResult::Clear,
            "new" | "n" => CommandResult::NewSession,
            "resume" | "r" | "load" => self.cmd_resume(cmd),
            "sessions" | "list" | "ls-sessions" => {
                CommandResult::Async("sessions:list".to_string())
            }
            "fork" | "branch" => self.cmd_fork(cmd),
            "rename" | "mv" => self.cmd_rename(cmd),
            "favorite" | "fav" | "star" => CommandResult::Toggle("favorite".to_string()),
            "unfavorite" | "unfav" | "unstar" => {
                CommandResult::SetValue("favorite".to_string(), "false".to_string())
            }
            "export" | "save" => self.cmd_export(cmd),
            "share" => self.cmd_share(cmd),
            "timeline" | "tl" => CommandResult::OpenModal(ModalType::Timeline),
            "undo" | "u" => CommandResult::Async("undo".to_string()),
            "redo" => CommandResult::Async("redo".to_string()),
            "rewind" | "rw" => self.cmd_rewind(cmd),
            "delete" | "rm" => self.cmd_delete(cmd),

            // Session branching from history (#3081)
            "branch-at" | "fork-at" => self.cmd_branch_at(cmd),

            // Edit previous message (#3088)
            "edit-message" | "edit-msg" | "em" => self.cmd_edit_message(cmd),

            // ============ NAVIGATION ============
            "diff" | "d" => self.cmd_diff(cmd),
            "transcript" | "tr" => CommandResult::Async("transcript".to_string()),
            "history" | "hist" => CommandResult::Async("history".to_string()),
            "scroll" => self.cmd_scroll(cmd),
            "goto" | "g" => self.cmd_goto(cmd),

            // ============ FILES ============
            "add" | "a" | "include" => self.cmd_add(cmd),
            "remove" | "rm-file" | "exclude" => self.cmd_remove(cmd),
            "search" | "find" | "grep" => self.cmd_search(cmd),
            "ls" | "dir" | "files" => self.cmd_ls(cmd),
            "mention" | "@" | "ref" => self.cmd_mention(cmd),
            "images" | "img" | "pics" => self.cmd_images(cmd),
            "tree" => self.cmd_tree(cmd),
            "context" | "ctx" => CommandResult::Async("context".to_string()),

            // ============ MODEL ============
            "model" | "m" => self.cmd_model(cmd),
            "models" | "lm" | "list-models" => {
                CommandResult::Async("models:fetch-and-pick".to_string())
            }
            "approval" | "approve" => self.cmd_approval(cmd),
            "sandbox" | "sb" => self.cmd_sandbox(cmd),
            "auto" | "autopilot" => self.cmd_auto(cmd),
            "provider" | "prov" => self.cmd_provider(cmd),
            "providers" | "lp" | "list-providers" => self.cmd_providers(),
            "temperature" | "temp" => self.cmd_temperature(cmd),
            "tokens" | "max-tokens" => self.cmd_tokens(cmd),

            // ============ MCP ============
            // All MCP commands redirect to the interactive panel
            "mcp" => self.cmd_mcp(cmd),
            "mcp-tools" | "tools" | "lt" => CommandResult::OpenModal(ModalType::McpManager),
            "mcp-auth" | "auth" => CommandResult::OpenModal(ModalType::McpManager),
            "mcp-reload" | "reload" => CommandResult::OpenModal(ModalType::McpManager),
            "mcp-logs" => CommandResult::OpenModal(ModalType::McpManager),

            // ============ DEBUG ============
            "debug" | "dbg" => self.cmd_debug(cmd),
            "status" | "stat" => CommandResult::Async("status".to_string()),
            "cfg" => self.cmd_cfg(cmd),
            "logs" | "log" => self.cmd_logs(cmd),
            "dump" => self.cmd_dump(cmd),
            "metrics" | "perf" => CommandResult::Async("metrics".to_string()),

            // Hidden commands
            "crash" => CommandResult::Error("Crash test triggered".to_string()),
            "eval" => self.cmd_eval(cmd),

            // Unknown (shouldn't reach here if registry check passed)
            _ => CommandResult::NotFound(format!("No handler for: /{}", cmd.name)),
        }
    }
}

// ============================================================
// INDIVIDUAL COMMAND HANDLERS
// ============================================================

impl CommandExecutor {
    // ========== GENERAL ==========

    fn cmd_help(&self, cmd: &ParsedCommand) -> CommandResult {
        let topic = cmd.first_arg().map(|s| s.to_string());
        CommandResult::OpenModal(ModalType::Help(topic))
    }

    fn cmd_version(&self) -> CommandResult {
        CommandResult::Message(format!(
            "Cortex TUI v{}\ncortex-core v{}",
            env!("CARGO_PKG_VERSION"),
            cortex_core::VERSION
        ))
    }

    fn cmd_theme(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(theme) => CommandResult::SetValue("theme".to_string(), theme.to_string()),
            None => CommandResult::OpenModal(ModalType::ThemePicker),
        }
    }

    /// Handles the /init command to initialize AGENTS.md in the project.
    ///
    /// Supports:
    /// - `/init` - Create AGENTS.md if it doesn't exist
    /// - `/init --force` - Overwrite existing AGENTS.md
    fn cmd_init(&self, cmd: &ParsedCommand) -> CommandResult {
        let force = cmd.args.iter().any(|a| a == "--force" || a == "-f");
        if force {
            CommandResult::Async("init:force".to_string())
        } else {
            CommandResult::Async("init".to_string())
        }
    }

    // ========== BILLING ==========

    /// Handles the /usage command with optional date range filters.
    ///
    /// Supports:
    /// - `/usage` - Show usage for current billing period
    /// - `/usage --from YYYY-MM-DD --to YYYY-MM-DD` - Show usage for date range
    fn cmd_usage(&self, cmd: &ParsedCommand) -> CommandResult {
        // Parse --from and --to arguments
        let mut from_date: Option<String> = None;
        let mut to_date: Option<String> = None;

        let mut args_iter = cmd.args.iter().peekable();
        while let Some(arg) = args_iter.next() {
            match arg.as_str() {
                "--from" | "-f" => {
                    if let Some(date) = args_iter.next() {
                        // Basic date format validation (YYYY-MM-DD)
                        if Self::is_valid_date_format(date) {
                            from_date = Some(date.clone());
                        } else {
                            return CommandResult::Error(format!(
                                "Invalid date format for --from: '{}'. Use YYYY-MM-DD.",
                                date
                            ));
                        }
                    } else {
                        return CommandResult::Error(
                            "--from requires a date argument (YYYY-MM-DD).".to_string(),
                        );
                    }
                }
                "--to" | "-t" => {
                    if let Some(date) = args_iter.next() {
                        if Self::is_valid_date_format(date) {
                            to_date = Some(date.clone());
                        } else {
                            return CommandResult::Error(format!(
                                "Invalid date format for --to: '{}'. Use YYYY-MM-DD.",
                                date
                            ));
                        }
                    } else {
                        return CommandResult::Error(
                            "--to requires a date argument (YYYY-MM-DD).".to_string(),
                        );
                    }
                }
                _ => {
                    // Ignore unknown arguments
                }
            }
        }

        // Build the async command string with optional date params
        let mut cmd_str = "billing:usage".to_string();
        if let Some(from) = from_date {
            cmd_str.push_str(&format!(":from={}", from));
        }
        if let Some(to) = to_date {
            cmd_str.push_str(&format!(":to={}", to));
        }

        CommandResult::Async(cmd_str)
    }

    /// Validates a date string is in YYYY-MM-DD format.
    fn is_valid_date_format(date: &str) -> bool {
        if date.len() != 10 {
            return false;
        }
        let parts: Vec<&str> = date.split('-').collect();
        if parts.len() != 3 {
            return false;
        }
        // Validate year (4 digits), month (2 digits), day (2 digits)
        parts[0].len() == 4
            && parts[0].chars().all(|c| c.is_ascii_digit())
            && parts[1].len() == 2
            && parts[1].chars().all(|c| c.is_ascii_digit())
            && parts[2].len() == 2
            && parts[2].chars().all(|c| c.is_ascii_digit())
    }

    // ========== SESSION ==========

    fn cmd_resume(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(id) => CommandResult::ResumeSession(id.to_string()),
            None => CommandResult::OpenModal(ModalType::Sessions),
        }
    }

    fn cmd_fork(&self, _cmd: &ParsedCommand) -> CommandResult {
        // Fork modal handles the name input
        CommandResult::OpenModal(ModalType::Fork)
    }

    fn cmd_rename(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(name) => CommandResult::SetValue("session_name".to_string(), name.to_string()),
            None => CommandResult::OpenModal(ModalType::Form("rename".to_string())),
        }
    }

    fn cmd_export(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(format) => match format.to_lowercase().as_str() {
                "md" | "markdown" => CommandResult::Async("export:markdown".to_string()),
                "json" => CommandResult::Async("export:json".to_string()),
                "txt" | "text" => CommandResult::Async("export:text".to_string()),
                _ => CommandResult::Error(format!(
                    "Unknown export format: {}. Use: md, json, or txt",
                    format
                )),
            },
            None => CommandResult::OpenModal(ModalType::Export(None)),
        }
    }

    /// Handles the /share command to generate a share link for the current session.
    ///
    /// Supports:
    /// - `/share` - Generate a share link with default duration (24h)
    /// - `/share 1h` - Generate a share link that expires in 1 hour
    /// - `/share 7d` - Generate a share link that expires in 7 days
    fn cmd_share(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(duration) => CommandResult::Async(format!("share:{}", duration)),
            None => CommandResult::Async("share".to_string()),
        }
    }

    fn cmd_rewind(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(steps) => {
                if let Ok(n) = steps.parse::<usize>() {
                    CommandResult::SetValue("rewind".to_string(), n.to_string())
                } else {
                    CommandResult::Error(format!("Invalid number: {}", steps))
                }
            }
            None => CommandResult::SetValue("rewind".to_string(), "1".to_string()),
        }
    }

    fn cmd_delete(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(id) => {
                CommandResult::OpenModal(ModalType::Confirm(format!("Delete session {}?", id)))
            }
            None => CommandResult::OpenModal(ModalType::Form("delete".to_string())),
        }
    }

    // ========== NAVIGATION ==========

    fn cmd_diff(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(file) => CommandResult::Async(format!("diff:{}", file)),
            None => CommandResult::Async("diff".to_string()),
        }
    }

    fn cmd_scroll(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some("top") => CommandResult::SetValue("scroll".to_string(), "top".to_string()),
            Some("bottom") => CommandResult::SetValue("scroll".to_string(), "bottom".to_string()),
            Some(n) => CommandResult::SetValue("scroll".to_string(), n.to_string()),
            None => CommandResult::OpenModal(ModalType::Form("scroll".to_string())),
        }
    }

    fn cmd_goto(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(n) => {
                if n.parse::<usize>().is_ok() {
                    CommandResult::SetValue("goto".to_string(), n.to_string())
                } else {
                    CommandResult::Error(format!("Invalid message number: {}", n))
                }
            }
            None => CommandResult::OpenModal(ModalType::Form("goto".to_string())),
        }
    }

    // ========== FILES ==========

    fn cmd_add(&self, cmd: &ParsedCommand) -> CommandResult {
        if cmd.args.is_empty() {
            CommandResult::OpenModal(ModalType::FilePicker)
        } else {
            // Use args_string_quoted to preserve filenames with spaces
            CommandResult::Async(format!("add:{}", cmd.args_string_quoted()))
        }
    }

    fn cmd_remove(&self, cmd: &ParsedCommand) -> CommandResult {
        if cmd.args.is_empty() {
            CommandResult::OpenModal(ModalType::Form("remove".to_string()))
        } else {
            // Use args_string_quoted to preserve filenames with spaces
            CommandResult::Async(format!("remove:{}", cmd.args_string_quoted()))
        }
    }

    fn cmd_search(&self, cmd: &ParsedCommand) -> CommandResult {
        if cmd.args.is_empty() {
            CommandResult::OpenModal(ModalType::Form("search".to_string()))
        } else {
            CommandResult::Async(format!("search:{}", cmd.args_string()))
        }
    }

    fn cmd_ls(&self, cmd: &ParsedCommand) -> CommandResult {
        let path = cmd.first_arg().unwrap_or(".");
        CommandResult::Async(format!("ls:{}", path))
    }

    fn cmd_mention(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(item) => CommandResult::Async(format!("mention:{}", item)),
            None => CommandResult::OpenModal(ModalType::Form("mention".to_string())),
        }
    }

    fn cmd_images(&self, cmd: &ParsedCommand) -> CommandResult {
        if cmd.args.is_empty() {
            CommandResult::Async("images:list".to_string())
        } else {
            CommandResult::Async(format!("images:add:{}", cmd.args.join(",")))
        }
    }

    fn cmd_tree(&self, cmd: &ParsedCommand) -> CommandResult {
        let path = cmd.first_arg().unwrap_or(".");
        CommandResult::Async(format!("tree:{}", path))
    }

    // ========== MODEL ==========

    fn cmd_model(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(model) => CommandResult::SetValue("model".to_string(), model.to_string()),
            None => CommandResult::OpenModal(ModalType::ModelPicker),
        }
    }

    fn cmd_approval(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(mode) => match mode.to_lowercase().as_str() {
                "ask" | "always" | "session" | "never" => {
                    CommandResult::SetValue("approval".to_string(), mode.to_string())
                }
                _ => CommandResult::Error(format!(
                    "Invalid approval mode: {}. Use ask|session|always|never",
                    mode
                )),
            },
            None => CommandResult::OpenModal(ModalType::ApprovalPicker),
        }
    }

    fn cmd_sandbox(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some("on") | Some("true") => {
                CommandResult::SetValue("sandbox".to_string(), "true".to_string())
            }
            Some("off") | Some("false") => {
                CommandResult::SetValue("sandbox".to_string(), "false".to_string())
            }
            None => CommandResult::Toggle("sandbox".to_string()),
            Some(other) => {
                CommandResult::Error(format!("Invalid sandbox value: {}. Use on|off", other))
            }
        }
    }

    fn cmd_auto(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some("on") | Some("true") => {
                CommandResult::SetValue("auto".to_string(), "true".to_string())
            }
            Some("off") | Some("false") => {
                CommandResult::SetValue("auto".to_string(), "false".to_string())
            }
            None => CommandResult::Toggle("auto".to_string()),
            Some(other) => {
                CommandResult::Error(format!("Invalid auto value: {}. Use on|off", other))
            }
        }
    }

    fn cmd_provider(&self, _cmd: &ParsedCommand) -> CommandResult {
        // Provider command is deprecated - Cortex is now a unified platform
        CommandResult::Message(
            "Warning: The /provider command is deprecated.\n\n\
             Cortex is now a unified platform - all model access goes through the Cortex backend.\n\
             Use /model to switch between available models instead."
                .to_string(),
        )
    }

    fn cmd_providers(&self) -> CommandResult {
        // Providers command is deprecated - Cortex is now a unified platform
        CommandResult::Message(
            "Warning: The /providers command is deprecated.\n\n\
             Cortex is now a unified platform with a single backend.\n\
             Use /models to see available models instead."
                .to_string(),
        )
    }

    fn cmd_temperature(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(temp) => {
                if let Ok(t) = temp.parse::<f32>() {
                    if (0.0..=2.0).contains(&t) {
                        CommandResult::SetValue("temperature".to_string(), temp.to_string())
                    } else {
                        CommandResult::Error("Temperature must be between 0.0 and 2.0".to_string())
                    }
                } else {
                    CommandResult::Error(format!("Invalid temperature: {}", temp))
                }
            }
            None => CommandResult::OpenModal(ModalType::Form("temperature".to_string())),
        }
    }

    fn cmd_tokens(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(n) => {
                if n.parse::<u32>().is_ok() {
                    CommandResult::SetValue("max_tokens".to_string(), n.to_string())
                } else {
                    CommandResult::Error(format!("Invalid token count: {}", n))
                }
            }
            None => CommandResult::OpenModal(ModalType::Form("tokens".to_string())),
        }
    }

    // ========== MCP ==========

    fn cmd_mcp(&self, _cmd: &ParsedCommand) -> CommandResult {
        // Always open the interactive MCP panel - all management is centralized there
        CommandResult::OpenModal(ModalType::McpManager)
    }

    fn cmd_mcp_auth(&self, _cmd: &ParsedCommand) -> CommandResult {
        // Deprecated: redirect to interactive MCP panel
        CommandResult::OpenModal(ModalType::McpManager)
    }

    fn cmd_mcp_logs(&self, _cmd: &ParsedCommand) -> CommandResult {
        // Deprecated: redirect to interactive MCP panel
        CommandResult::OpenModal(ModalType::McpManager)
    }

    // ========== DEBUG ==========

    fn cmd_debug(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some("on") | Some("true") => {
                CommandResult::SetValue("debug".to_string(), "true".to_string())
            }
            Some("off") | Some("false") => {
                CommandResult::SetValue("debug".to_string(), "false".to_string())
            }
            None => CommandResult::Toggle("debug".to_string()),
            Some(other) => {
                CommandResult::Error(format!("Invalid debug value: {}. Use on|off", other))
            }
        }
    }

    fn cmd_cfg(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(key) => CommandResult::Async(format!("config:get:{}", key)),
            None => CommandResult::Async("config:list".to_string()),
        }
    }

    fn cmd_logs(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(level) => CommandResult::Async(format!("logs:{}", level)),
            None => CommandResult::OpenModal(ModalType::LogLevelPicker),
        }
    }

    fn cmd_dump(&self, cmd: &ParsedCommand) -> CommandResult {
        let file = match cmd.first_arg() {
            Some(path) => path.to_string(),
            None => {
                // Generate unique filename with timestamp to prevent overwrites
                let timestamp = Local::now().format("%Y%m%d_%H%M%S");
                format!("session_dump_{}.json", timestamp)
            }
        };
        CommandResult::Async(format!("dump:{}", file))
    }

    fn cmd_eval(&self, cmd: &ParsedCommand) -> CommandResult {
        if cmd.args.is_empty() {
            CommandResult::OpenModal(ModalType::Form("eval".to_string()))
        } else {
            CommandResult::Async(format!("eval:{}", cmd.args_string()))
        }
    }

    // ========== NEW COMMANDS (#3081-3090) ==========

    /// Handles the /branch-at command to create a branch from a specific message in history.
    /// (#3081 Session Branching from History Points)
    ///
    /// Supports:
    /// - `/branch-at <index>` - Branch from message at index (1-based)
    fn cmd_branch_at(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(index) => {
                if let Ok(n) = index.parse::<usize>() {
                    if n == 0 {
                        return CommandResult::Error(
                            "Message index must be 1 or greater.".to_string(),
                        );
                    }
                    CommandResult::Async(format!("session:branch-at:{}", n))
                } else {
                    CommandResult::Error(format!("Invalid message index: {}. Use a number.", index))
                }
            }
            None => CommandResult::Error(
                "Usage: /branch-at <message-index>\nExample: /branch-at 5".to_string(),
            ),
        }
    }

    /// Handles the /edit-message command to edit and resend a previous message.
    /// (#3088 Message Editing in Interactive Mode)
    ///
    /// Supports:
    /// - `/edit-message` - Edit the last user message
    /// - `/edit-message <index>` - Edit message at specific index
    fn cmd_edit_message(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(index) => {
                if let Ok(n) = index.parse::<usize>() {
                    CommandResult::Async(format!("message:edit:{}", n))
                } else {
                    CommandResult::Error(format!("Invalid message index: {}", index))
                }
            }
            // Default to editing the last user message
            None => CommandResult::Async("message:edit:last".to_string()),
        }
    }

    /// Handles the /macro command for prompt macros.
    /// (#3085 Prompt Macros for Reusable Text)
    ///
    /// Supports:
    /// - `/macro list` - List all saved macros
    /// - `/macro save <name> <content>` - Save a new macro
    /// - `/macro delete <name>` - Delete a macro
    /// - `/macro use <name>` - Insert macro content into input
    /// - `/macro <name>` - Shorthand for use
    fn cmd_macro(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some("list") | Some("ls") => CommandResult::Async("macro:list".to_string()),
            Some("save") | Some("add") => {
                if cmd.args.len() < 3 {
                    return CommandResult::Error("Usage: /macro save <name> <content>".to_string());
                }
                let name = &cmd.args[1];
                let content = cmd.args[2..].join(" ");
                CommandResult::Async(format!("macro:save:{}:{}", name, content))
            }
            Some("delete") | Some("rm") => {
                if cmd.args.len() < 2 {
                    return CommandResult::Error("Usage: /macro delete <name>".to_string());
                }
                let name = &cmd.args[1];
                CommandResult::Async(format!("macro:delete:{}", name))
            }
            Some("use") => {
                if cmd.args.len() < 2 {
                    return CommandResult::Error("Usage: /macro use <name>".to_string());
                }
                let name = &cmd.args[1];
                CommandResult::Async(format!("macro:use:{}", name))
            }
            Some(name) => {
                // Shorthand: /macro <name> is equivalent to /macro use <name>
                CommandResult::Async(format!("macro:use:{}", name))
            }
            None => CommandResult::Async("macro:list".to_string()),
        }
    }

    /// Handles the /validate-config command for configuration validation.
    /// (#3090 Configuration Validation Command)
    ///
    /// Supports:
    /// - `/validate-config` - Validate default config
    /// - `/validate-config <path>` - Validate specific config file
    fn cmd_validate_config(&self, cmd: &ParsedCommand) -> CommandResult {
        match cmd.first_arg() {
            Some(path) => CommandResult::Async(format!("config:validate:{}", path)),
            None => CommandResult::Async("config:validate".to_string()),
        }
    }
}

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

// ============================================================
// TESTS
// ============================================================

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

    #[test]
    fn test_execute_quit() {
        let executor = CommandExecutor::new();
        let cmd = ParsedCommand::new("quit".to_string(), vec![], "/quit".to_string());
        assert!(matches!(executor.execute(&cmd), CommandResult::Quit));
    }

    #[test]
    fn test_execute_quit_alias() {
        let executor = CommandExecutor::new();
        let cmd = ParsedCommand::new("q".to_string(), vec![], "/q".to_string());
        assert!(matches!(executor.execute(&cmd), CommandResult::Quit));
    }

    #[test]
    fn test_execute_exit_alias() {
        let executor = CommandExecutor::new();
        let cmd = ParsedCommand::new("exit".to_string(), vec![], "/exit".to_string());
        assert!(matches!(executor.execute(&cmd), CommandResult::Quit));
    }

    #[test]
    fn test_execute_help() {
        let executor = CommandExecutor::new();
        let cmd = ParsedCommand::new("help".to_string(), vec![], "/help".to_string());
        assert!(matches!(
            executor.execute(&cmd),
            CommandResult::OpenModal(ModalType::Help(None))
        ));
    }

    #[test]
    fn test_execute_help_topic() {
        let executor = CommandExecutor::new();
        let cmd = ParsedCommand::new(
            "help".to_string(),
            vec!["keys".to_string()],
            "/help keys".to_string(),
        );
        if let CommandResult::OpenModal(ModalType::Help(Some(topic))) = executor.execute(&cmd) {
            assert_eq!(topic, "keys");
        } else {
            panic!("Expected Help modal with topic");
        }
    }

    #[test]
    fn test_execute_unknown() {
        let executor = CommandExecutor::new();
        let cmd = ParsedCommand::new("foobar".to_string(), vec![], "/foobar".to_string());
        assert!(matches!(executor.execute(&cmd), CommandResult::NotFound(_)));
    }

    #[test]
    fn test_execute_str() {
        let executor = CommandExecutor::new();
        assert!(matches!(executor.execute_str("/quit"), CommandResult::Quit));
        assert!(matches!(
            executor.execute_str("/clear"),
            CommandResult::Clear
        ));
    }

    #[test]
    fn test_execute_str_invalid() {
        let executor = CommandExecutor::new();
        assert!(matches!(
            executor.execute_str("not a command"),
            CommandResult::Error(_)
        ));
    }

    #[test]
    fn test_model_with_arg() {
        let executor = CommandExecutor::new();
        let result = executor.execute_str("/model gpt-4");
        if let CommandResult::SetValue(key, value) = result {
            assert_eq!(key, "model");
            assert_eq!(value, "gpt-4");
        } else {
            panic!("Expected SetValue");
        }
    }

    #[test]
    fn test_model_without_arg() {
        let executor = CommandExecutor::new();
        let result = executor.execute_str("/model");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::ModelPicker)
        ));
    }

    #[test]
    fn test_needs_args() {
        let executor = CommandExecutor::new();
        let result = executor.execute_str("/rename");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::Form(_))
        ));
    }

    #[test]
    fn test_clear() {
        let executor = CommandExecutor::new();
        assert!(matches!(
            executor.execute_str("/clear"),
            CommandResult::Clear
        ));
        assert!(matches!(executor.execute_str("/cls"), CommandResult::Clear));
    }

    #[test]
    fn test_new_session() {
        let executor = CommandExecutor::new();
        assert!(matches!(
            executor.execute_str("/new"),
            CommandResult::NewSession
        ));
        assert!(matches!(
            executor.execute_str("/n"),
            CommandResult::NewSession
        ));
    }

    #[test]
    fn test_resume_with_id() {
        let executor = CommandExecutor::new();
        let result = executor.execute_str("/resume abc123");
        if let CommandResult::ResumeSession(id) = result {
            assert_eq!(id, "abc123");
        } else {
            panic!("Expected ResumeSession");
        }
    }

    #[test]
    fn test_resume_without_id() {
        let executor = CommandExecutor::new();
        let result = executor.execute_str("/resume");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::Sessions)
        ));
    }

    #[test]
    fn test_toggle_commands() {
        let executor = CommandExecutor::new();

        // compact
        let result = executor.execute_str("/compact");
        assert!(matches!(result, CommandResult::Toggle(ref s) if s == "compact"));

        // favorite
        let result = executor.execute_str("/favorite");
        assert!(matches!(result, CommandResult::Toggle(ref s) if s == "favorite"));

        // sandbox without arg
        let result = executor.execute_str("/sandbox");
        assert!(matches!(result, CommandResult::Toggle(ref s) if s == "sandbox"));
    }

    #[test]
    fn test_sandbox_with_args() {
        let executor = CommandExecutor::new();

        let result = executor.execute_str("/sandbox on");
        assert!(matches!(
            result,
            CommandResult::SetValue(ref k, ref v) if k == "sandbox" && v == "true"
        ));

        let result = executor.execute_str("/sandbox off");
        assert!(matches!(
            result,
            CommandResult::SetValue(ref k, ref v) if k == "sandbox" && v == "false"
        ));

        let result = executor.execute_str("/sandbox invalid");
        assert!(matches!(result, CommandResult::Error(_)));
    }

    #[test]
    fn test_temperature_validation() {
        let executor = CommandExecutor::new();

        // Valid
        let result = executor.execute_str("/temperature 0.7");
        assert!(matches!(
            result,
            CommandResult::SetValue(ref k, ref v) if k == "temperature" && v == "0.7"
        ));

        // Out of range
        let result = executor.execute_str("/temperature 3.0");
        assert!(matches!(result, CommandResult::Error(_)));

        // Invalid number
        let result = executor.execute_str("/temperature abc");
        assert!(matches!(result, CommandResult::Error(_)));

        // Missing arg
        let result = executor.execute_str("/temperature");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::Form(_))
        ));
    }

    #[test]
    fn test_approval_modes() {
        let executor = CommandExecutor::new();

        for mode in &["ask", "session", "always", "never"] {
            let result = executor.execute_str(&format!("/approval {}", mode));
            assert!(matches!(
                result,
                CommandResult::SetValue(ref k, _) if k == "approval"
            ));
        }

        let result = executor.execute_str("/approval invalid");
        assert!(matches!(result, CommandResult::Error(_)));
    }

    #[test]
    fn test_async_commands() {
        let executor = CommandExecutor::new();

        assert!(matches!(
            executor.execute_str("/undo"),
            CommandResult::Async(ref s) if s == "undo"
        ));

        assert!(matches!(
            executor.execute_str("/redo"),
            CommandResult::Async(ref s) if s == "redo"
        ));

        assert!(matches!(
            executor.execute_str("/transcript"),
            CommandResult::Async(ref s) if s == "transcript"
        ));

        assert!(matches!(
            executor.execute_str("/status"),
            CommandResult::Async(ref s) if s == "status"
        ));
    }

    #[test]
    fn test_add_command() {
        let executor = CommandExecutor::new();

        // Without args opens file picker
        let result = executor.execute_str("/add");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::FilePicker)
        ));

        // With args triggers async add (space-separated, not comma-separated)
        let result = executor.execute_str("/add file1.txt file2.txt");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "add:file1.txt file2.txt"
        ));

        // With quoted args containing spaces
        let result = executor.execute_str("/add \"my file.txt\" other.txt");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "add:\"my file.txt\" other.txt"
        ));
    }

    #[test]
    fn test_search_command() {
        let executor = CommandExecutor::new();

        let result = executor.execute_str("/search");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::Form(_))
        ));

        let result = executor.execute_str("/search pattern");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "search:pattern"
        ));
    }

    #[test]
    fn test_mcp_subcommands() {
        let executor = CommandExecutor::new();

        // /mcp and /mcp list now open the MCP Manager modal
        let result = executor.execute_str("/mcp");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::McpManager)
        ));

        let result = executor.execute_str("/mcp list");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::McpManager)
        ));

        // All mcp subcommands now redirect to the interactive panel
        let result = executor.execute_str("/mcp status");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::McpManager)
        ));

        let result = executor.execute_str("/mcp add myserver");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::McpManager)
        ));

        let result = executor.execute_str("/mcp add");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::McpManager)
        ));
    }

    #[test]
    fn test_rewind_command() {
        let executor = CommandExecutor::new();

        // Without arg defaults to 1
        let result = executor.execute_str("/rewind");
        assert!(matches!(
            result,
            CommandResult::SetValue(ref k, ref v) if k == "rewind" && v == "1"
        ));

        // With valid number
        let result = executor.execute_str("/rewind 5");
        assert!(matches!(
            result,
            CommandResult::SetValue(ref k, ref v) if k == "rewind" && v == "5"
        ));

        // With invalid number
        let result = executor.execute_str("/rewind abc");
        assert!(matches!(result, CommandResult::Error(_)));
    }

    #[test]
    fn test_version() {
        let executor = CommandExecutor::new();
        let result = executor.execute_str("/version");
        if let CommandResult::Message(msg) = result {
            assert!(msg.contains("Cortex TUI"));
        } else {
            panic!("Expected Message");
        }
    }

    #[test]
    fn test_registry_access() {
        let executor = CommandExecutor::new();
        let registry = executor.registry();
        assert!(registry.exists("help"));
        assert!(registry.exists("quit"));
    }

    #[test]
    fn test_goto_validation() {
        let executor = CommandExecutor::new();

        let result = executor.execute_str("/goto 5");
        assert!(matches!(
            result,
            CommandResult::SetValue(ref k, ref v) if k == "goto" && v == "5"
        ));

        let result = executor.execute_str("/goto abc");
        assert!(matches!(result, CommandResult::Error(_)));

        let result = executor.execute_str("/goto");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::Form(_))
        ));
    }

    #[test]
    fn test_scroll_command() {
        let executor = CommandExecutor::new();

        let result = executor.execute_str("/scroll top");
        assert!(matches!(
            result,
            CommandResult::SetValue(ref k, ref v) if k == "scroll" && v == "top"
        ));

        let result = executor.execute_str("/scroll bottom");
        assert!(matches!(
            result,
            CommandResult::SetValue(ref k, ref v) if k == "scroll" && v == "bottom"
        ));

        let result = executor.execute_str("/scroll 10");
        assert!(matches!(
            result,
            CommandResult::SetValue(ref k, ref v) if k == "scroll" && v == "10"
        ));

        let result = executor.execute_str("/scroll");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::Form(_))
        ));
    }

    #[test]
    fn test_default_impl() {
        let executor = CommandExecutor::default();
        assert!(executor.registry().exists("help"));
    }

    #[test]
    fn test_init_command() {
        let executor = CommandExecutor::new();

        let result = executor.execute_str("/init");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "init"
        ));

        let result = executor.execute_str("/init --force");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "init:force"
        ));

        let result = executor.execute_str("/init -f");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "init:force"
        ));
    }

    #[test]
    fn test_commands_command() {
        let executor = CommandExecutor::new();

        let result = executor.execute_str("/commands");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "commands:list"
        ));
    }

    #[test]
    fn test_agents_command() {
        let executor = CommandExecutor::new();

        let result = executor.execute_str("/agents");
        assert!(matches!(
            result,
            CommandResult::OpenModal(ModalType::Agents)
        ));
    }

    #[test]
    fn test_share_command() {
        let executor = CommandExecutor::new();

        let result = executor.execute_str("/share");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "share"
        ));

        let result = executor.execute_str("/share 1h");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "share:1h"
        ));

        let result = executor.execute_str("/share 7d");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "share:7d"
        ));
    }

    // ========== NEW COMMANDS TESTS (#3081-3090) ==========

    #[test]
    fn test_branch_at_command() {
        let executor = CommandExecutor::new();

        // With valid index
        let result = executor.execute_str("/branch-at 5");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "session:branch-at:5"
        ));

        // Without argument
        let result = executor.execute_str("/branch-at");
        assert!(matches!(result, CommandResult::Error(_)));

        // With invalid index
        let result = executor.execute_str("/branch-at abc");
        assert!(matches!(result, CommandResult::Error(_)));

        // With zero index
        let result = executor.execute_str("/branch-at 0");
        assert!(matches!(result, CommandResult::Error(_)));
    }

    #[test]
    fn test_edit_message_command() {
        let executor = CommandExecutor::new();

        // Without argument - edit last
        let result = executor.execute_str("/edit-message");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "message:edit:last"
        ));

        // With index
        let result = executor.execute_str("/edit-message 3");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "message:edit:3"
        ));

        // Alias
        let result = executor.execute_str("/em 2");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "message:edit:2"
        ));
    }

    #[test]
    fn test_macro_command() {
        let executor = CommandExecutor::new();

        // List macros
        let result = executor.execute_str("/macro list");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "macro:list"
        ));

        // Save macro
        let result = executor.execute_str("/macro save greeting Hello, world!");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s.starts_with("macro:save:greeting:")
        ));

        // Delete macro
        let result = executor.execute_str("/macro delete greeting");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "macro:delete:greeting"
        ));

        // Use macro
        let result = executor.execute_str("/macro use greeting");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "macro:use:greeting"
        ));

        // Shorthand use
        let result = executor.execute_str("/macro greeting");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "macro:use:greeting"
        ));

        // No args - list
        let result = executor.execute_str("/macro");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "macro:list"
        ));
    }

    #[test]
    fn test_validate_config_command() {
        let executor = CommandExecutor::new();

        // Without path
        let result = executor.execute_str("/validate-config");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "config:validate"
        ));

        // With path
        let result = executor.execute_str("/validate-config /path/to/config.toml");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "config:validate:/path/to/config.toml"
        ));

        // Alias
        let result = executor.execute_str("/check-config");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "config:validate"
        ));
    }

    #[test]
    fn test_paste_command() {
        let executor = CommandExecutor::new();

        let result = executor.execute_str("/paste");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "clipboard:paste"
        ));
    }

    #[test]
    fn test_editor_command() {
        let executor = CommandExecutor::new();

        let result = executor.execute_str("/editor");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "editor:open"
        ));

        // Alias
        let result = executor.execute_str("/vi");
        assert!(matches!(
            result,
            CommandResult::Async(ref s) if s == "editor:open"
        ));
    }
}