use crate::agent_events::AgentEvent;
use crate::ai::{AiConfig, AiModelInfo, AiTestConnectionResult};
use crate::ai_cli_agent::{
    append_config_overrides, build_cli_agent_prompt, cli_command, dbx_mcp_enabled_tools, dbx_mcp_scope_env,
    model_infos, parse_cli_jsonl_event, run_cli_jsonl_agent, toml_string, toml_string_array, CliAgentCommandSpec,
    CliAgentJsonlDialect, CliAgentProcessSpec, CliAgentRunOptions,
};
use serde_json::Value;
use std::collections::{BTreeMap, BTreeSet};
use std::env;
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::time::Instant;
use tokio::process::Command;
use tokio::sync::Notify;

const DEFAULT_CODEX_MODELS: &[&str] = &["default", "gpt-5.5", "gpt-5.4-mini"];
#[cfg(not(windows))]
const CODEX_PATH_MARKER: &str = "__DBX_CODEX_PATH__";

pub type CodexRunOptions = CliAgentRunOptions;
pub type CodexCommandSpec = CliAgentCommandSpec;

fn codex_program(config: &AiConfig) -> String {
    config.codex_cli_path.as_deref().map(str::trim).filter(|path| !path.is_empty()).unwrap_or("codex").to_string()
}

async fn resolve_codex_command(config: &AiConfig) -> CodexCommandSpec {
    let configured = codex_program(config);
    if is_path_like_program(&configured) {
        let expanded = expand_tilde(&configured);
        return codex_command_for_program(direct_program_path(&expanded).unwrap_or(expanded));
    }
    if let Some(path) = resolve_program_path(&configured).await {
        codex_command_for_program(path)
    } else {
        CodexCommandSpec { program: configured, args: Vec::new() }
    }
}

fn codex_command_for_program(program: String) -> CodexCommandSpec {
    #[cfg(windows)]
    if let Some(command) = windows_npm_codex_shim_command(&program) {
        return command;
    }

    CodexCommandSpec { program, args: Vec::new() }
}

#[cfg(windows)]
fn windows_npm_codex_shim_command(program: &str) -> Option<CodexCommandSpec> {
    let path = Path::new(program);
    let extension = path.extension()?.to_str()?.to_ascii_lowercase();
    if extension != "cmd" && extension != "bat" {
        return None;
    }

    let parent = path.parent()?;
    let codex_js = parent.join("node_modules").join("@openai").join("codex").join("bin").join("codex.js");
    if !codex_js.is_file() {
        return None;
    }

    let bundled_node = parent.join("node.exe");
    let node = if bundled_node.is_file() { bundled_node.to_string_lossy().to_string() } else { "node".to_string() };

    Some(CodexCommandSpec { program: node, args: vec![codex_js.to_string_lossy().to_string()] })
}

fn codex_process_env(config: &AiConfig, command: &CodexCommandSpec) -> Result<Vec<(String, String)>, String> {
    let mut env = BTreeMap::from_iter(codex_cli_env(config)?);
    if let Some(dir) = command.parent_dir() {
        let user_path = env.get("PATH").map(String::as_str);
        env.insert("PATH".to_string(), merged_path_with_dir(&dir, user_path));
    }
    Ok(env.into_iter().collect())
}

trait CommandParentDir {
    fn parent_dir(&self) -> Option<String>;
}

impl CommandParentDir for CodexCommandSpec {
    fn parent_dir(&self) -> Option<String> {
        Path::new(&self.program)
            .parent()
            .filter(|parent| !parent.as_os_str().is_empty())
            .map(|parent| parent.to_string_lossy().to_string())
    }
}

async fn resolve_program_path(program: &str) -> Option<String> {
    if let Some(path) = direct_program_path(program) {
        return Some(path);
    }
    if let Some(path) = common_program_path(program) {
        return Some(path);
    }
    shell_program_path(program).await
}

fn direct_program_path(program: &str) -> Option<String> {
    let path = Path::new(program);
    if !path.is_absolute() {
        return None;
    }

    if path.is_dir() {
        return launchable_program_in_dir(path, "codex");
    }

    if path.is_file() {
        #[cfg(windows)]
        return windows_launchable_program_path(path);
        #[cfg(not(windows))]
        return Some(path.to_string_lossy().to_string());
    }

    None
}

fn launchable_program_in_dir(dir: &Path, program: &str) -> Option<String> {
    program_path_candidates(dir, program)
        .into_iter()
        .find(|candidate| is_launchable_program_path(candidate) && candidate.is_file())
        .map(|path| path.to_string_lossy().to_string())
}

#[cfg(windows)]
fn windows_launchable_program_path(path: &Path) -> Option<String> {
    if is_windows_launchable_program(path) {
        return Some(path.to_string_lossy().to_string());
    }
    let parent = path.parent()?;
    let stem = path.file_name()?.to_str()?;
    program_path_candidates(parent, stem)
        .into_iter()
        .find(|candidate| is_windows_launchable_program(candidate))
        .and_then(|candidate| candidate.is_file().then(|| candidate.to_string_lossy().to_string()))
}

#[cfg(windows)]
fn is_windows_launchable_program(path: &Path) -> bool {
    matches!(
        path.extension().and_then(|extension| extension.to_str()).map(str::to_ascii_lowercase).as_deref(),
        Some("exe" | "cmd" | "bat" | "com")
    )
}

fn common_program_path(program: &str) -> Option<String> {
    common_executable_dirs()
        .into_iter()
        .flat_map(|dir| program_path_candidates(&dir, program))
        .filter(|path| is_launchable_program_path(path))
        .find(|path| path.is_file())
        .map(|path| path.to_string_lossy().to_string())
}

#[cfg(not(windows))]
fn is_launchable_program_path(_path: &Path) -> bool {
    true
}

#[cfg(windows)]
fn is_launchable_program_path(path: &Path) -> bool {
    is_windows_launchable_program(path)
}

#[cfg(not(windows))]
fn program_path_candidates(dir: &Path, program: &str) -> Vec<PathBuf> {
    vec![dir.join(program)]
}

#[cfg(windows)]
fn program_path_candidates(dir: &Path, program: &str) -> Vec<PathBuf> {
    let path = Path::new(program);
    if path.extension().is_some() {
        return vec![dir.join(program)];
    }
    [".cmd", ".exe", ".bat", ".com", "", ".ps1"]
        .iter()
        .map(|extension| dir.join(format!("{program}{extension}")))
        .collect()
}

#[cfg(not(windows))]
async fn shell_program_path(program: &str) -> Option<String> {
    let script = shell_resolve_script(program);
    let mut command = Command::new(user_shell());
    command.args(user_shell_args(&script));
    command.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
    let output = command.output().await.ok()?;
    output.status.success().then_some(())?;
    let stdout = String::from_utf8_lossy(&output.stdout);
    stdout
        .find(CODEX_PATH_MARKER)
        .and_then(|index| {
            stdout[index + CODEX_PATH_MARKER.len()..].lines().map(str::trim).find(|line| !line.is_empty())
        })
        .filter(|path| Path::new(path).is_file())
        .map(ToString::to_string)
}

#[cfg(windows)]
async fn shell_program_path(program: &str) -> Option<String> {
    let script = format!("(Get-Command -All {} -ErrorAction SilentlyContinue).Source", windows_shell_quote(program));
    let mut command = Command::new("powershell.exe");
    command.args(["-NoProfile", "-Command", &script]);
    command.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
    let output = command.output().await.ok()?;
    output.status.success().then_some(())?;
    let stdout = String::from_utf8_lossy(&output.stdout);
    first_windows_program_path(&stdout)
}

#[cfg(windows)]
fn first_windows_program_path(value: &str) -> Option<String> {
    let paths = value.lines().map(str::trim).filter(|line| !line.is_empty()).collect::<Vec<_>>();
    paths
        .into_iter()
        .find(|path| is_windows_launchable_program(Path::new(path)) && Path::new(path).is_file())
        .map(ToOwned::to_owned)
}

#[cfg(windows)]
fn windows_shell_quote(value: &str) -> String {
    format!("'{}'", value.replace('\'', "''"))
}

fn is_path_like_program(program: &str) -> bool {
    program.contains('/') || program.contains('\\') || program.starts_with('~')
}

fn expand_tilde(path: &str) -> String {
    crate::path_utils::expand_tilde(path)
}

fn common_executable_dirs() -> Vec<PathBuf> {
    let mut dirs = Vec::new();
    if let Ok(path) = env::var("PATH") {
        dirs.extend(env::split_paths(&path));
    }
    #[cfg(windows)]
    {
        if let Ok(app_data) = env::var("APPDATA") {
            dirs.push(PathBuf::from(app_data).join("npm"));
        }
    }
    #[cfg(not(windows))]
    {
        dirs.extend([
            PathBuf::from("/opt/homebrew/bin"),
            PathBuf::from("/usr/local/bin"),
            PathBuf::from("/usr/bin"),
            PathBuf::from("/bin"),
            PathBuf::from("/usr/sbin"),
            PathBuf::from("/sbin"),
        ]);
    }
    dirs
}

fn merged_path_with_dir(dir: &str, user_path: Option<&str>) -> String {
    let mut seen = BTreeSet::new();
    let mut dirs = vec![PathBuf::from(dir)];
    if let Some(path) = user_path {
        dirs.extend(env::split_paths(path));
    }
    dirs.extend(common_executable_dirs());
    let paths = dirs.into_iter().filter(|path| seen.insert(path.clone())).collect::<Vec<_>>();
    env::join_paths(paths).unwrap_or_default().to_string_lossy().to_string()
}

#[cfg(not(windows))]
fn user_shell() -> String {
    env::var("SHELL").ok().filter(|value| !value.trim().is_empty()).unwrap_or_else(|| {
        if Path::new("/bin/zsh").exists() {
            "/bin/zsh".to_string()
        } else {
            "/bin/sh".to_string()
        }
    })
}

#[cfg(not(windows))]
fn user_shell_args(script: &str) -> Vec<String> {
    let shell = user_shell();
    let shell_name = Path::new(&shell).file_name().and_then(|value| value.to_str()).unwrap_or_default();
    match shell_name {
        "fish" => vec!["-l".to_string(), "-i".to_string(), "-c".to_string(), script.to_string()],
        "bash" => vec![
            "--noprofile".to_string(),
            "--norc".to_string(),
            "-i".to_string(),
            "-c".to_string(),
            bash_login_script(script),
        ],
        "sh" | "dash" => vec!["-ic".to_string(), script.to_string()],
        "zsh" => vec!["-ilc".to_string(), script.to_string()],
        _ => vec!["-lc".to_string(), script.to_string()],
    }
}

#[cfg(not(windows))]
fn bash_login_script(script: &str) -> String {
    format!(
        "for dbx_profile in ~/.bash_profile ~/.bash_login ~/.profile ~/.bashrc; do \
         [ -r \"$dbx_profile\" ] && . \"$dbx_profile\"; \
         done; unset dbx_profile; {script}"
    )
}

#[cfg(not(windows))]
fn shell_resolve_script(program: &str) -> String {
    format!("printf '%s\\n' {}; command -v {}", shell_quote(CODEX_PATH_MARKER), shell_quote(program))
}

#[cfg(not(windows))]
fn shell_quote(value: &str) -> String {
    if value.is_empty() {
        return "''".to_string();
    }
    format!("'{}'", value.replace('\'', "'\"'\"'"))
}

fn validate_codex_program(config: &AiConfig) -> Result<String, String> {
    let program = codex_program(config);
    if starts_with_env_assignment(&program) {
        return Err("[codexCliPathInvalid] Codex CLI path should contain only the executable path. Add environment variables in the Codex CLI environment variables section.".to_string());
    }
    if is_path_like_program(&program) {
        let expanded = expand_tilde(&program);
        let path = Path::new(&expanded);
        if path.is_dir() && direct_program_path(&expanded).is_none() {
            return Err("[codexCliPathInvalid] Codex CLI path should point to the Codex executable or a directory containing codex.".to_string());
        }
    }
    Ok(program)
}

pub fn codex_cli_env(config: &AiConfig) -> Result<Vec<(String, String)>, String> {
    let mut env = BTreeMap::new();
    for (key, value) in &config.codex_cli_env {
        let key = key.trim();
        if key.is_empty() {
            continue;
        }
        if !is_env_var_name(key) {
            return Err(format!(
                "[codexEnvInvalid] Invalid Codex CLI environment variable name `{key}`. Use names like HTTPS_PROXY."
            ));
        }
        if is_reserved_dbx_mcp_env_name(key) {
            return Err(format!(
                "[codexEnvReserved] `{key}` is managed by DBX for the scoped MCP server and cannot be set here."
            ));
        }
        env.insert(key.to_string(), value.clone());
    }
    Ok(env.into_iter().collect())
}

fn starts_with_env_assignment(program: &str) -> bool {
    let Some(first_token) = program.split_whitespace().next() else {
        return false;
    };
    let Some((key, _)) = first_token.split_once('=') else {
        return false;
    };
    is_env_var_name(key)
}

fn is_env_var_name(name: &str) -> bool {
    let mut chars = name.chars();
    let Some(first) = chars.next() else {
        return false;
    };
    (first == '_' || first.is_ascii_alphabetic()) && chars.all(|ch| ch == '_' || ch.is_ascii_alphanumeric())
}

fn is_reserved_dbx_mcp_env_name(name: &str) -> bool {
    name.to_ascii_uppercase().starts_with("DBX_MCP_")
}

pub fn codex_enabled_tools(agent_mode: bool) -> Vec<&'static str> {
    dbx_mcp_enabled_tools(agent_mode)
}

fn codex_mcp_config_overrides(options: &CodexRunOptions) -> Vec<String> {
    let mcp_command =
        options.mcp_server_command.as_ref().map(|command| command.program.as_str()).unwrap_or("dbx-mcp-server");
    let mut overrides = vec![
        format!("mcp_servers.dbx.command={}", toml_string(mcp_command)),
        "mcp_servers.dbx.required=true".to_string(),
        "mcp_servers.dbx.startup_timeout_sec=20".to_string(),
        "mcp_servers.dbx.tool_timeout_sec=120".to_string(),
        "mcp_servers.dbx.default_tools_approval_mode=\"approve\"".to_string(),
        format!("mcp_servers.dbx.enabled_tools={}", toml_string_array(&dbx_mcp_enabled_tools(options.agent_mode))),
    ];
    if let Some(command) = options.mcp_server_command.as_ref().filter(|command| !command.args.is_empty()) {
        let args = command.args.iter().map(String::as_str).collect::<Vec<_>>();
        overrides.push(format!("mcp_servers.dbx.args={}", toml_string_array(&args)));
    }
    overrides.extend(
        dbx_mcp_scope_env(options)
            .into_iter()
            .map(|(name, value)| format!("mcp_servers.dbx.env.{name}={}", toml_string(&value))),
    );
    overrides
}

pub fn build_codex_exec_command(config: &AiConfig, _prompt: &str, options: &CodexRunOptions) -> CodexCommandSpec {
    let mut args = vec![
        "exec".to_string(),
        "--json".to_string(),
        "--skip-git-repo-check".to_string(),
        "--sandbox".to_string(),
        "read-only".to_string(),
    ];
    let mut config_overrides = vec!["features.shell_tool=false".to_string(), "web_search=\"disabled\"".to_string()];
    if let Some(reasoning_effort) = config.reasoning_level.as_codex_effort() {
        config_overrides.push(format!("model_reasoning_effort={}", toml_string(reasoning_effort)));
    }
    append_config_overrides(&mut args, config_overrides.into_iter().chain(codex_mcp_config_overrides(options)));

    let model = config.model.trim();
    if !model.is_empty() && !model.eq_ignore_ascii_case("default") {
        args.push("--model".to_string());
        args.push(model.to_string());
    }

    args.push("-".to_string());

    CodexCommandSpec { program: codex_program(config), args }
}

pub fn build_codex_prompt(system_prompt: &str, messages: &[crate::ai::AiMessage]) -> String {
    build_cli_agent_prompt("Codex", system_prompt, messages)
}

pub async fn list_codex_models(config: &AiConfig) -> Result<Vec<AiModelInfo>, String> {
    validate_codex_program(config)?;
    let command = resolve_codex_command(config).await;
    let output = cli_command(&command.program)
        .args(command.args.iter().map(String::as_str))
        .args(["debug", "models"])
        .envs(codex_process_env(config, &command)?.iter().map(|(key, value)| (key.as_str(), value.as_str())))
        .output()
        .await;

    let Ok(output) = output else {
        return Ok(model_infos(DEFAULT_CODEX_MODELS));
    };
    if !output.status.success() {
        return Ok(model_infos(DEFAULT_CODEX_MODELS));
    }

    Ok(parse_codex_models(&String::from_utf8_lossy(&output.stdout))
        .unwrap_or_else(|| model_infos(DEFAULT_CODEX_MODELS)))
}

fn parse_codex_models(stdout: &str) -> Option<Vec<AiModelInfo>> {
    let json_start = stdout.find('{')?;
    let data = serde_json::from_str::<Value>(&stdout[json_start..]).ok()?;
    let models = data.get("models").and_then(Value::as_array)?;

    let mut result = vec![AiModelInfo { id: "default".to_string(), display_name: Some("Default".to_string()) }];
    for model in models {
        let Some(id) = model
            .get("slug")
            .and_then(Value::as_str)
            .or_else(|| model.get("id").and_then(Value::as_str))
            .map(str::trim)
            .filter(|id| !id.is_empty())
        else {
            continue;
        };
        if result.iter().any(|existing| existing.id == id) {
            continue;
        }
        let display_name = model
            .get("display_name")
            .and_then(Value::as_str)
            .map(str::trim)
            .filter(|name| !name.is_empty())
            .map(ToString::to_string);
        result.push(AiModelInfo { id: id.to_string(), display_name });
    }

    (result.len() > 1).then_some(result)
}

pub async fn test_codex_connection(config: &AiConfig) -> Result<AiTestConnectionResult, String> {
    let start = Instant::now();
    validate_codex_program(config)?;
    let codex_command = resolve_codex_command(config).await;
    let mut command = cli_command(&codex_command.program);
    command.args(codex_command.args.iter().map(String::as_str));
    command.args(["login", "status"]);
    command.envs(codex_process_env(config, &codex_command)?.iter().map(|(key, value)| (key.as_str(), value.as_str())));

    let output = command.output().await.map_err(|e| classify_codex_spawn_error(&e.to_string()))?;

    if output.status.success() {
        Ok(AiTestConnectionResult {
            success: true,
            message: format!("OK - {}ms", start.elapsed().as_millis()),
            latency_ms: Some(start.elapsed().as_millis() as u64),
            model_used: config.model.trim().to_string(),
            error_category: None,
        })
    } else {
        let stderr = String::from_utf8_lossy(&output.stderr);
        Err(classify_codex_run_error(&stderr))
    }
}

fn classify_codex_spawn_error(message: &str) -> String {
    if message.contains("No such file") || message.contains("not found") {
        "[codexNotInstalled] Codex CLI was not found. Install Codex CLI or set the Codex CLI path in DBX AI settings."
            .to_string()
    } else if is_command_line_too_long_error(message) {
        "[codexCommandLineTooLong] Codex CLI command line is too long. Update DBX so Codex prompts are sent through stdin instead of process arguments."
            .to_string()
    } else {
        format!("[codexRunFailed] Failed to start Codex CLI: {message}")
    }
}

fn is_command_line_too_long_error(message: &str) -> bool {
    let lower = message.to_ascii_lowercase();
    message.contains("os error 206")
        || message.contains("文件名或扩展名太长")
        || lower.contains("filename or extension is too long")
        || lower.contains("the filename or extension is too long")
}

fn classify_codex_run_error(stderr: &str) -> String {
    let lower = stderr.to_ascii_lowercase();
    if lower.contains("not authenticated") || lower.contains("login") || lower.contains("auth") {
        format!("[codexNotAuthenticated] Codex CLI is not authenticated. Run `codex login` and try again. {stderr}")
    } else if lower.contains("dbx-mcp-server") || lower.contains("enoent") {
        format!("[dbxMcpMissing] DBX MCP server was not found. Install @dbx-app/mcp-server and try again. {stderr}")
    } else if lower.contains("mcp") && (lower.contains("dbx") || lower.contains("server")) {
        format!("[codexMcpStartupFailed] Codex could not start the DBX MCP server. {stderr}")
    } else {
        format!("[codexRunFailed] Codex CLI failed. {stderr}")
    }
}

pub fn parse_codex_jsonl_event(line: &str) -> Option<Vec<AgentEvent>> {
    parse_cli_jsonl_event(line, CliAgentJsonlDialect::CodexExec)
}

pub async fn run_codex_agent(
    config: &AiConfig,
    prompt: &str,
    options: CodexRunOptions,
    cancelled: &Notify,
    on_event: impl Fn(AgentEvent) + Send + Sync + 'static,
) -> Result<String, String> {
    validate_codex_program(config)?;
    let mut command = build_codex_exec_command(config, prompt, &options);
    let resolved_command = resolve_codex_command(config).await;
    command.program = resolved_command.program;
    command.args.splice(0..0, resolved_command.args);
    let env = codex_process_env(config, &command)?;
    run_cli_jsonl_agent(
        CliAgentProcessSpec {
            command,
            env,
            stdin: Some(prompt.to_string()),
            dialect: CliAgentJsonlDialect::CodexExec,
            classify_spawn_error: classify_codex_spawn_error,
            classify_run_error: classify_codex_run_error,
        },
        cancelled,
        on_event,
    )
    .await
}

#[cfg(test)]
mod tests {
    #[cfg(not(windows))]
    use super::shell_quote;
    use super::{
        build_codex_exec_command, classify_codex_spawn_error, codex_cli_env, codex_enabled_tools, is_path_like_program,
        parse_codex_jsonl_event, parse_codex_models, validate_codex_program, CodexRunOptions, DEFAULT_CODEX_MODELS,
    };
    #[cfg(not(windows))]
    use super::{codex_process_env, common_executable_dirs, merged_path_with_dir};
    #[cfg(windows)]
    use super::{
        direct_program_path, first_windows_program_path, program_path_candidates, resolve_codex_command,
        windows_npm_codex_shim_command,
    };
    use crate::agent_events::AgentEvent;
    use crate::ai::{AiApiStyle, AiAuthMethod, AiConfig, AiProvider, AiReasoningLevel};
    use crate::ai_cli_agent::{model_infos, CliAgentCommandSpec};

    fn codex_config(model: &str) -> AiConfig {
        AiConfig {
            provider: AiProvider::CodexCli,
            api_key: String::new(),
            auth_method: AiAuthMethod::Bearer,
            endpoint: String::new(),
            model: model.to_string(),
            api_style: AiApiStyle::Completions,
            proxy_enabled: false,
            proxy_url: String::new(),
            enable_thinking: true,
            reasoning_level: AiReasoningLevel::Default,
            context_window: None,
            codex_cli_path: None,
            codex_cli_env: Default::default(),
        }
    }

    fn run_options() -> CodexRunOptions {
        CodexRunOptions {
            connection_id: "conn-1".to_string(),
            connection_name: "local".to_string(),
            database: "demo".to_string(),
            agent_mode: true,
            mcp_server_command: None,
        }
    }

    #[test]
    fn builds_codex_command_with_scoped_mcp_and_omits_default_model() {
        let spec = build_codex_exec_command(&codex_config("default"), "hello", &run_options());

        assert_eq!(spec.program, "codex");
        assert!(spec.args.contains(&"--json".to_string()));
        assert_eq!(spec.args.last().map(String::as_str), Some("-"));
        assert!(!spec.args.contains(&"hello".to_string()));
        assert!(!spec.args.contains(&"--model".to_string()));
        assert!(!spec.args.contains(&"--ask-for-approval".to_string()));
        assert!(spec.args.contains(&"mcp_servers.dbx.command=\"dbx-mcp-server\"".to_string()));
        assert!(spec.args.contains(&"mcp_servers.dbx.default_tools_approval_mode=\"approve\"".to_string()));
        assert!(spec.args.contains(&"mcp_servers.dbx.env.DBX_MCP_ALLOW_WRITES=\"0\"".to_string()));
        assert!(spec.args.contains(&"mcp_servers.dbx.env.DBX_MCP_SCOPE_CONNECTION_ID=\"conn-1\"".to_string()));
        assert!(spec.args.iter().any(|arg| arg.contains("dbx_execute_query")));
    }

    #[test]
    fn builds_codex_command_with_non_default_model_and_ask_tools() {
        let mut options = run_options();
        options.agent_mode = false;
        let spec = build_codex_exec_command(&codex_config("gpt-5.5"), "hello", &options);

        let model_pos = spec.args.iter().position(|arg| arg == "--model").unwrap();
        assert_eq!(spec.args[model_pos + 1], "gpt-5.5");
        assert!(!codex_enabled_tools(false).contains(&"dbx_execute_query"));
        assert!(spec.args.iter().any(|arg| arg.contains("dbx_get_schema_context")));
        assert!(!spec.args.iter().any(|arg| arg.contains("dbx_execute_query")));
    }

    #[test]
    fn builds_codex_command_with_resolved_mcp_server_path() {
        let mut options = run_options();
        options.mcp_server_command = Some(CliAgentCommandSpec {
            program: "/opt/dbx/bin/dbx-mcp-server".to_string(),
            args: vec!["--stdio".to_string()],
        });
        let spec = build_codex_exec_command(&codex_config("default"), "hello", &options);

        assert!(spec.args.contains(&"mcp_servers.dbx.command=\"/opt/dbx/bin/dbx-mcp-server\"".to_string()));
        assert!(spec.args.contains(&"mcp_servers.dbx.args=[\"--stdio\"]".to_string()));
    }

    #[test]
    fn builds_codex_command_with_reasoning_effort_override() {
        let mut config = codex_config("default");
        config.reasoning_level = AiReasoningLevel::High;
        let spec = build_codex_exec_command(&config, "hello", &run_options());

        assert!(!spec.args.contains(&"--reasoning-effort".to_string()));
        assert!(spec.args.contains(&"model_reasoning_effort=\"high\"".to_string()));
    }

    #[test]
    fn path_like_codex_programs_are_detected() {
        assert!(is_path_like_program("/opt/homebrew/bin/codex"));
        assert!(is_path_like_program("~/bin/codex"));
        assert!(is_path_like_program(r"C:\Tools\codex.exe"));
        assert!(!is_path_like_program("codex"));
    }

    #[test]
    #[cfg(windows)]
    fn windows_codex_lookup_prefers_cmd_over_extensionless_shim() {
        let candidates = program_path_candidates(std::path::Path::new(r"C:\nvm4w\nodejs"), "codex");

        assert_eq!(candidates[0], std::path::Path::new(r"C:\nvm4w\nodejs\codex.cmd"));
        assert!(candidates.iter().position(|path| path == std::path::Path::new(r"C:\nvm4w\nodejs\codex")).unwrap() > 0);
    }

    #[test]
    #[cfg(windows)]
    fn windows_shell_lookup_prefers_launchable_command() {
        let dir = std::env::temp_dir().join(format!("dbx-codex-test-{}", std::process::id()));
        std::fs::create_dir_all(&dir).unwrap();
        let extensionless = dir.join("codex");
        let cmd = dir.join("codex.cmd");
        std::fs::write(&extensionless, "#!/bin/sh\n").unwrap();
        std::fs::write(&cmd, "@echo off\n").unwrap();

        let output = format!("{}\n{}\n", extensionless.display(), cmd.display());
        let resolved = first_windows_program_path(&output).unwrap();

        assert_eq!(resolved, cmd.to_string_lossy());
        let _ = std::fs::remove_file(extensionless);
        let _ = std::fs::remove_file(cmd);
        let _ = std::fs::remove_dir(dir);
    }

    #[test]
    #[cfg(windows)]
    fn windows_direct_extensionless_path_uses_cmd_sibling() {
        let dir = std::env::temp_dir().join(format!("dbx-codex-direct-test-{}", std::process::id()));
        std::fs::create_dir_all(&dir).unwrap();
        let extensionless = dir.join("codex");
        let cmd = dir.join("codex.cmd");
        std::fs::write(&extensionless, "#!/bin/sh\n").unwrap();
        std::fs::write(&cmd, "@echo off\n").unwrap();

        let resolved = direct_program_path(extensionless.to_string_lossy().as_ref()).unwrap();

        assert_eq!(resolved, cmd.to_string_lossy().as_ref());
        let _ = std::fs::remove_file(extensionless);
        let _ = std::fs::remove_file(cmd);
        let _ = std::fs::remove_dir(dir);
    }

    #[test]
    #[cfg(windows)]
    fn windows_direct_extensionless_path_is_not_launchable_without_sibling() {
        let dir = std::env::temp_dir().join(format!("dbx-codex-direct-missing-test-{}", std::process::id()));
        std::fs::create_dir_all(&dir).unwrap();
        let extensionless = dir.join("codex");
        std::fs::write(&extensionless, "#!/bin/sh\n").unwrap();

        let resolved = direct_program_path(extensionless.to_string_lossy().as_ref());

        assert!(resolved.is_none());
        let _ = std::fs::remove_file(extensionless);
        let _ = std::fs::remove_dir(dir);
    }

    #[test]
    #[cfg(windows)]
    fn windows_direct_directory_path_uses_codex_cmd_inside() {
        let dir = std::env::temp_dir().join(format!("dbx-codex-direct-dir-test-{}", std::process::id()));
        std::fs::create_dir_all(&dir).unwrap();
        let extensionless = dir.join("codex");
        let cmd = dir.join("codex.cmd");
        std::fs::write(&extensionless, "#!/bin/sh\n").unwrap();
        std::fs::write(&cmd, "@echo off\n").unwrap();

        let resolved = direct_program_path(dir.to_string_lossy().as_ref()).unwrap();

        assert_eq!(resolved, cmd.to_string_lossy().as_ref());
        let _ = std::fs::remove_file(extensionless);
        let _ = std::fs::remove_file(cmd);
        let _ = std::fs::remove_dir(dir);
    }

    #[tokio::test]
    #[cfg(windows)]
    async fn windows_configured_nvm_directory_resolves_codex_cmd_shim() {
        let dir = std::env::temp_dir().join(format!("dbx-codex-nvm-dir-test-{}", std::process::id()));
        let bin_dir = dir.join("node_modules").join("@openai").join("codex").join("bin");
        std::fs::create_dir_all(&bin_dir).unwrap();
        let cmd = dir.join("codex.cmd");
        let node = dir.join("node.exe");
        let codex_js = bin_dir.join("codex.js");
        std::fs::write(&cmd, "@echo off\nnode codex.js %*\n").unwrap();
        std::fs::write(&node, "").unwrap();
        std::fs::write(&codex_js, "#!/usr/bin/env node\n").unwrap();

        let mut config = codex_config("default");
        config.codex_cli_path = Some(dir.to_string_lossy().to_string());

        let command = resolve_codex_command(&config).await;

        assert_eq!(command.program, node.to_string_lossy().as_ref());
        assert_eq!(command.args, vec![codex_js.to_string_lossy().to_string()]);
        let _ = std::fs::remove_file(cmd);
        let _ = std::fs::remove_file(node);
        let _ = std::fs::remove_file(codex_js);
        let _ = std::fs::remove_dir_all(dir);
    }

    #[test]
    #[cfg(windows)]
    fn windows_npm_codex_cmd_shim_uses_node_directly() {
        let dir = std::env::temp_dir().join(format!("dbx-codex-npm-shim-test-{}", std::process::id()));
        let bin_dir = dir.join("node_modules").join("@openai").join("codex").join("bin");
        std::fs::create_dir_all(&bin_dir).unwrap();
        let cmd = dir.join("codex.cmd");
        let node = dir.join("node.exe");
        let codex_js = bin_dir.join("codex.js");
        std::fs::write(&cmd, "@echo off\nnode codex.js %*\n").unwrap();
        std::fs::write(&node, "").unwrap();
        std::fs::write(&codex_js, "#!/usr/bin/env node\n").unwrap();

        let command = windows_npm_codex_shim_command(cmd.to_string_lossy().as_ref()).unwrap();

        assert_eq!(command.program, node.to_string_lossy().as_ref());
        assert_eq!(command.args, vec![codex_js.to_string_lossy().to_string()]);
        let _ = std::fs::remove_file(cmd);
        let _ = std::fs::remove_file(node);
        let _ = std::fs::remove_file(codex_js);
        let _ = std::fs::remove_dir_all(dir);
    }

    #[test]
    #[cfg(not(windows))]
    fn common_codex_lookup_dirs_include_homebrew_and_system_paths() {
        let dirs = common_executable_dirs();

        assert!(dirs.iter().any(|dir| dir == std::path::Path::new("/opt/homebrew/bin")));
        assert!(dirs.iter().any(|dir| dir == std::path::Path::new("/usr/local/bin")));
        assert!(dirs.iter().any(|dir| dir == std::path::Path::new("/usr/bin")));
    }

    #[test]
    #[cfg(not(windows))]
    fn codex_command_env_prepends_resolved_program_dir_and_keeps_node_dirs() {
        let config = codex_config("default");
        let command = CliAgentCommandSpec { program: "/opt/homebrew/bin/codex".to_string(), args: Vec::new() };
        let env = codex_process_env(&config, &command).unwrap();
        let path = env.iter().find(|(key, _)| key == "PATH").map(|(_, value)| value).unwrap();
        let dirs = std::env::split_paths(path).collect::<Vec<_>>();

        assert_eq!(dirs.first().unwrap(), std::path::Path::new("/opt/homebrew/bin"));
        assert!(dirs.iter().any(|dir| dir == std::path::Path::new("/usr/bin")));
    }

    #[test]
    #[cfg(not(windows))]
    fn merged_path_deduplicates_codex_dir() {
        let path = merged_path_with_dir("/opt/homebrew/bin", None);
        let dirs = std::env::split_paths(&path).collect::<Vec<_>>();
        let count = dirs.iter().filter(|dir| *dir == std::path::Path::new("/opt/homebrew/bin")).count();

        assert_eq!(count, 1);
    }

    #[test]
    #[cfg(not(windows))]
    fn codex_process_env_keeps_resolved_program_dir_before_user_path() {
        let mut config = codex_config("default");
        config.codex_cli_env.insert("PATH".to_string(), "/custom/bin:/usr/bin".to_string());
        let command = CliAgentCommandSpec { program: "/opt/homebrew/bin/codex".to_string(), args: Vec::new() };

        let env = codex_process_env(&config, &command).unwrap();
        let path = env.iter().find(|(key, _)| key == "PATH").map(|(_, value)| value).unwrap();
        let dirs = std::env::split_paths(path).collect::<Vec<_>>();

        assert_eq!(dirs.first().unwrap(), std::path::Path::new("/opt/homebrew/bin"));
        assert!(dirs.iter().any(|dir| dir == std::path::Path::new("/custom/bin")));
    }

    #[test]
    #[cfg(not(windows))]
    fn shell_quote_handles_codex_program_names() {
        assert_eq!(shell_quote("codex"), "'codex'");
        assert_eq!(shell_quote("can't"), "'can'\"'\"'t'");
    }

    #[test]
    fn default_model_list_matches_plan() {
        assert_eq!(model_infos(DEFAULT_CODEX_MODELS), model_infos(&["default", "gpt-5.5", "gpt-5.4-mini"]));
    }

    #[test]
    fn normalizes_codex_cli_env() {
        let mut config = codex_config("default");
        config.codex_cli_env.insert(" HTTPS_PROXY ".to_string(), "http://proxy:9800".to_string());
        config.codex_cli_env.insert("NO_PROXY".to_string(), "localhost,127.0.0.1".to_string());
        config.codex_cli_env.insert("".to_string(), "ignored".to_string());

        let env = codex_cli_env(&config).unwrap();

        assert_eq!(
            env,
            vec![
                ("HTTPS_PROXY".to_string(), "http://proxy:9800".to_string()),
                ("NO_PROXY".to_string(), "localhost,127.0.0.1".to_string())
            ]
        );
    }

    #[test]
    fn rejects_invalid_codex_cli_env_name() {
        let mut config = codex_config("default");
        config.codex_cli_env.insert("BAD-NAME".to_string(), "value".to_string());

        let err = codex_cli_env(&config).unwrap_err();

        assert!(err.contains("[codexEnvInvalid]"));
    }

    #[test]
    fn rejects_reserved_dbx_mcp_env_name() {
        let mut config = codex_config("default");
        config.codex_cli_env.insert("DBX_MCP_ALLOW_DANGEROUS_SQL".to_string(), "1".to_string());

        let err = codex_cli_env(&config).unwrap_err();

        assert!(err.contains("[codexEnvReserved]"));
    }

    #[test]
    fn rejects_shell_style_env_prefix_in_codex_cli_path() {
        let mut config = codex_config("default");
        config.codex_cli_path = Some("HTTPS_PROXY=http://proxy:9800 /opt/homebrew/bin/codex".to_string());

        let err = validate_codex_program(&config).unwrap_err();

        assert!(err.contains("[codexCliPathInvalid]"));
        assert!(err.contains("environment variables section"));
    }

    #[test]
    fn rejects_directory_without_codex_in_codex_cli_path() {
        let dir = std::env::temp_dir().join(format!("dbx-codex-empty-dir-test-{}", std::process::id()));
        std::fs::create_dir_all(&dir).unwrap();
        let mut config = codex_config("default");
        config.codex_cli_path = Some(dir.to_string_lossy().to_string());

        let err = validate_codex_program(&config).unwrap_err();

        assert!(err.contains("[codexCliPathInvalid]"));
        let _ = std::fs::remove_dir(dir);
    }

    #[test]
    fn parses_codex_model_catalog_without_service_tiers() {
        let models = parse_codex_models(
            r#"{"models":[{"slug":"gpt-5.5","display_name":"GPT-5.5","service_tiers":[{"id":"priority","name":"Priority"}]},{"slug":"gpt-5.4-mini","display_name":"GPT-5.4 mini"}]}"#,
        )
        .unwrap();

        assert_eq!(
            models.iter().map(|model| model.id.as_str()).collect::<Vec<_>>(),
            vec!["default", "gpt-5.5", "gpt-5.4-mini"]
        );
        assert_eq!(models[1].display_name.as_deref(), Some("GPT-5.5"));
        assert!(!models.iter().any(|model| model.id == "priority" || model.id == "Priority"));
    }

    #[test]
    fn classifies_windows_command_line_too_long_spawn_error() {
        let err = classify_codex_spawn_error("文件名或扩展名太长。 (os error 206)");

        assert!(err.contains("[codexCommandLineTooLong]"));
    }

    #[test]
    fn parses_codex_jsonl_events() {
        assert!(parse_codex_jsonl_event(r#"{"type":"thread.started","thread_id":"t"}"#).is_none());

        let started = parse_codex_jsonl_event(
            r#"{"type":"item.started","item":{"id":"tool-1","type":"mcp_tool_call","tool_name":"dbx_list_tables","arguments":{"schema":"public"}}}"#,
        )
        .unwrap();
        assert!(matches!(&started[0], AgentEvent::ToolCallStart { tool_name, .. } if tool_name == "dbx_list_tables"));

        let completed = parse_codex_jsonl_event(
            r#"{"type":"item.completed","item":{"id":"msg-1","type":"agent_message","text":"Done"}}"#,
        )
        .unwrap();
        assert!(matches!(&completed[0], AgentEvent::TextDelta { delta } if delta == "Done"));

        let tool_done = parse_codex_jsonl_event(
            r#"{"type":"item.completed","item":{"id":"tool-1","type":"mcp_tool_call","tool_name":"dbx_list_tables","result":{"content":"users"}}}"#,
        )
        .unwrap();
        assert!(
            matches!(&tool_done[0], AgentEvent::ToolCallEnd { tool_name, is_error, .. } if tool_name == "dbx_list_tables" && !is_error)
        );

        let current_started = parse_codex_jsonl_event(
            r#"{"type":"item.started","item":{"id":"item_0","type":"mcp_tool_call","server":"dbx","tool":"dbx_execute_query","arguments":{"sql":"SELECT 1"},"result":null,"error":null,"status":"in_progress"}}"#,
        )
        .unwrap();
        assert!(
            matches!(&current_started[0], AgentEvent::ToolCallStart { tool_name, args, .. } if tool_name == "dbx_execute_query" && args["sql"] == "SELECT 1")
        );

        let current_tool_done = parse_codex_jsonl_event(
            r#"{"type":"item.completed","item":{"id":"item_0","type":"mcp_tool_call","server":"dbx","tool":"dbx_execute_query","arguments":{"sql":"SELECT 1"},"result":{"content":[{"type":"text","text":"ok"}],"structured_content":null},"error":null,"status":"completed"}}"#,
        )
        .unwrap();
        assert!(
            matches!(&current_tool_done[0], AgentEvent::ToolCallEnd { tool_name, result, is_error, .. } if tool_name == "dbx_execute_query" && result["content"][0]["text"] == "ok" && !is_error)
        );

        let current_tool_error = parse_codex_jsonl_event(
            r#"{"type":"item.completed","item":{"id":"item_0","type":"mcp_tool_call","server":"dbx","tool":"dbx_execute_query","arguments":{"sql":"SELECT 1"},"result":null,"error":{"message":"user cancelled MCP tool call"},"status":"failed"}}"#,
        )
        .unwrap();
        assert!(
            matches!(&current_tool_error[0], AgentEvent::ToolCallEnd { tool_name, result, is_error, .. } if tool_name == "dbx_execute_query" && result["message"] == "user cancelled MCP tool call" && *is_error)
        );

        let turn_done =
            parse_codex_jsonl_event(r#"{"type":"turn.completed","usage":{"input_tokens":12,"output_tokens":3}}"#)
                .unwrap();
        assert!(matches!(&turn_done[0], AgentEvent::AgentEnd { input_tokens: Some(12), output_tokens: Some(3) }));

        let failed = parse_codex_jsonl_event(r#"{"type":"turn.failed","message":"boom"}"#).unwrap();
        assert!(matches!(&failed[0], AgentEvent::Error { message } if message == "boom"));
    }
}