//! Spawns the long-running agent process behind a thread: the `claude` CLI
//! speaking stream-json (the transport the Claude Agent SDKs use), Pi in its
//! JSONL RPC mode, or jcode's harness API bridge, which connects to jcode's
//! shared daemon. All read commands on stdin and stream events on stdout.

use std::{
    io::{BufRead, BufReader, Write},
    os::unix::process::CommandExt,
    path::{Path, PathBuf},
    process::{Child, Command, Stdio},
    sync::{Arc, Mutex, mpsc},
    thread,
};

use anyhow::{Context as _, Result, anyhow};
use serde_json::{Value, json};

use crate::browser;
use crate::orchestrator;
use crate::models::Provider;
use crate::settings::{ProviderInstance, expand_home};

/// Environment variables that mark a process as running *inside* another
/// Claude Code session. They leak in when this app is launched from a Claude
/// Code terminal and make the child CLI behave like a nested session.
const NESTED_SESSION_ENV: &[&str] = &[
    "CLAUDECODE",
    "CLAUDE_CODE_ENTRYPOINT",
    "CLAUDE_CODE_SESSION_ID",
    "CLAUDE_CODE_CHILD_SESSION",
    "CLAUDE_CODE_SESSION_ATTENDED",
    "CLAUDE_CODE_EXECPATH",
    "CLAUDE_CODE_MESSAGING_SOCKET",
    "CLAUDE_CODE_MESSAGING_TOKEN",
    "CLAUDE_AGENT_SDK_VERSION",
    "CLAUDE_PID",
];

#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
pub enum PermissionMode {
    #[default]
    Default,
    AcceptEdits,
    /// Claude's classifier approves routine actions and asks about the rest.
    Auto,
    Plan,
    BypassPermissions,
}

impl PermissionMode {
    pub const ALL: [PermissionMode; 5] = [
        PermissionMode::Default,
        PermissionMode::AcceptEdits,
        PermissionMode::Auto,
        PermissionMode::Plan,
        PermissionMode::BypassPermissions,
    ];

    pub fn as_cli(self) -> &'static str {
        match self {
            PermissionMode::Default => "default",
            PermissionMode::AcceptEdits => "acceptEdits",
            PermissionMode::Auto => "auto",
            PermissionMode::Plan => "plan",
            PermissionMode::BypassPermissions => "bypassPermissions",
        }
    }

    pub fn from_cli(value: &str) -> Option<Self> {
        Self::ALL.into_iter().find(|mode| mode.as_cli() == value)
    }

    pub fn label(self) -> &'static str {
        match self {
            PermissionMode::Default => "Supervised",
            PermissionMode::AcceptEdits => "Auto-accept edits",
            PermissionMode::Auto => "Auto",
            PermissionMode::Plan => "Plan",
            PermissionMode::BypassPermissions => "Full access",
        }
    }

    pub fn description(self) -> &'static str {
        match self {
            PermissionMode::Default => "Ask before commands and file changes.",
            PermissionMode::AcceptEdits => "Auto-approve edits, ask before other actions.",
            PermissionMode::Auto => "Supported providers approve routine actions; others still ask.",
            PermissionMode::Plan => "Read-only: Claude plans before it changes anything.",
            PermissionMode::BypassPermissions => "Allow commands and edits without prompts.",
        }
    }
}

/// How hard the model thinks: Claude's `--effort` levels and Pi's thinking
/// levels, which add `off` and `minimal`.
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum Effort {
    Off,
    Minimal,
    Low,
    Medium,
    High,
    XHigh,
    Max,
}

impl Effort {
    pub const ALL: [Effort; 7] =
        [Effort::Off, Effort::Minimal, Effort::Low, Effort::Medium, Effort::High, Effort::XHigh, Effort::Max];

    pub fn as_cli(self) -> &'static str {
        match self {
            Effort::Off => "off",
            Effort::Minimal => "minimal",
            Effort::Low => "low",
            Effort::Medium => "medium",
            Effort::High => "high",
            Effort::XHigh => "xhigh",
            Effort::Max => "max",
        }
    }

    pub fn from_cli(value: &str) -> Option<Self> {
        Self::ALL.into_iter().find(|effort| effort.as_cli() == value)
    }

    pub fn label(self) -> &'static str {
        match self {
            Effort::Off => "Off",
            Effort::Minimal => "Minimal",
            Effort::Low => "Low",
            Effort::Medium => "Medium",
            Effort::High => "High",
            Effort::XHigh => "Extra High",
            Effort::Max => "Max",
        }
    }
}

#[derive(Clone, Debug)]
pub struct LaunchConfig {
    /// Which agent, with its binary, home folder, arguments and environment.
    pub instance: ProviderInstance,
    pub cwd: PathBuf,
    /// A Claude model alias, `provider/model` for Pi, or a jcode model spec.
    /// `None` is the default.
    pub model: Option<String>,
    pub permission_mode: PermissionMode,
    /// `None` leaves effort at the model's default.
    pub effort: Option<Effort>,
    /// Session to resume (a Claude or jcode session id, or a Pi session
    /// file), used to restart a thread whose process stopped.
    pub resume: Option<String>,
    /// The thread's agent-browser session, shared with the browser panel.
    pub browser_session: Option<String>,
    /// The thread the agent runs for.
    pub thread: String,
    /// Which of the app's tools it gets: subagents (not in subagents' own
    /// threads) and devices (when agent device access is on).
    pub tools: orchestrator::Caps,
}

/// Everything the background reader threads report back to the UI.
#[derive(Debug)]
pub enum ProcessEvent {
    Message(Value),
    Stderr(String),
    Exited(Option<i32>),
}

pub struct AgentProcess {
    child: Arc<Mutex<Child>>,
    stdin_tx: mpsc::Sender<String>,
}

impl AgentProcess {
    pub fn spawn(config: &LaunchConfig, events: smol::channel::Sender<ProcessEvent>) -> Result<Self> {
        let (binary, mut command) = match config.instance.kind {
            Provider::Claude => claude_command(config)?,
            Provider::Pi => pi_command(config)?,
            // jcode's tools run in its daemon, out of reach of this process's
            // environment; the thread tells it about the browser in a message.
            Provider::Jcode => jcode_command(config)?,
        };
        // The app's tools; jcode's are registered over its API.
        orchestrator::set_caps(&config.thread, config.tools);
        match config.instance.kind {
            Provider::Claude => {
                if let Some(mcp) = config.tools.any().then(|| orchestrator::claude_config(&config.thread)).flatten() {
                    let allowed = format!("mcp__{}", orchestrator::SERVER);
                    command.args(["--mcp-config", &mcp, "--allowedTools", &allowed]);
                }
            }
            Provider::Pi => orchestrator::prepare_pi(&mut command, &config.thread, config.tools),
            Provider::Jcode => {}
        }
        // The agent-device launcher, on PATH for agents that may drive devices.
        if config.tools.devices {
            crate::device::agent::prepare_command(&mut command);
        }
        // Claude and Pi take extra system prompt with this flag.
        if config.instance.kind != Provider::Jcode
            && let Some(session) = &config.browser_session
            && let Some(prompt) = browser::prepare_agent(&mut command, session)
        {
            command.args(["--append-system-prompt", &prompt]);
        }
        Self::spawn_command(&binary, command, events)
    }

    fn spawn_command(
        binary: &Path,
        mut command: Command,
        events: smol::channel::Sender<ProcessEvent>,
    ) -> Result<Self> {
        command.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped());
        // Take the agent down with us if the app dies without cleaning up.
        unsafe {
            command.pre_exec(|| {
                libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM);
                Ok(())
            });
        }

        let mut child = command
            .spawn()
            .with_context(|| format!("failed to start {}", binary.display()))?;
        let stdout = child.stdout.take().context("missing stdout pipe")?;
        let stderr = child.stderr.take().context("missing stderr pipe")?;
        let mut stdin = child.stdin.take().context("missing stdin pipe")?;
        let child = Arc::new(Mutex::new(child));

        // Writes happen on their own thread so the UI never blocks on a full pipe.
        let (stdin_tx, stdin_rx) = mpsc::channel::<String>();
        thread::Builder::new()
            .name("agent-stdin".into())
            .spawn(move || {
                for line in stdin_rx {
                    if stdin.write_all(line.as_bytes()).is_err()
                        || stdin.write_all(b"\n").is_err()
                        || stdin.flush().is_err()
                    {
                        break;
                    }
                }
            })?;

        let stderr_events = events.clone();
        thread::Builder::new()
            .name("agent-stderr".into())
            .spawn(move || {
                for line in BufReader::new(stderr).lines().map_while(Result::ok) {
                    if !line.trim().is_empty() {
                        let _ = stderr_events.send_blocking(ProcessEvent::Stderr(line));
                    }
                }
            })?;

        let reader_child = child.clone();
        thread::Builder::new()
            .name("agent-stdout".into())
            .spawn(move || {
                // `lines()` splits on LF only, as Pi's JSONL framing requires.
                for line in BufReader::new(stdout).lines().map_while(Result::ok) {
                    let line = line.trim();
                    if line.is_empty() {
                        continue;
                    }
                    let event = match serde_json::from_str::<Value>(line) {
                        Ok(value) => ProcessEvent::Message(value),
                        Err(_) => ProcessEvent::Stderr(line.to_string()),
                    };
                    if events.send_blocking(event).is_err() {
                        return;
                    }
                }
                let code = reader_child
                    .lock()
                    .ok()
                    .and_then(|mut child| child.wait().ok())
                    .and_then(|status| status.code());
                let _ = events.send_blocking(ProcessEvent::Exited(code));
            })?;

        Ok(Self { child, stdin_tx })
    }

    pub fn send(&self, message: Value) {
        let _ = self.stdin_tx.send(message.to_string());
    }

    /// Sends a Claude user turn made of API content blocks (text, images).
    pub fn send_user_content(&self, content: Vec<Value>) {
        self.send(json!({
            "type": "user",
            "message": {"role": "user", "content": content},
            "parent_tool_use_id": null,
        }));
    }

    pub fn send_control(&self, request_id: &str, request: Value) {
        self.send(json!({"type": "control_request", "request_id": request_id, "request": request}));
    }

    pub fn respond_control(&self, request_id: &str, response: Value) {
        self.send(json!({
            "type": "control_response",
            "response": {"subtype": "success", "request_id": request_id, "response": response},
        }));
    }

    pub fn kill(&self) {
        if let Ok(mut child) = self.child.lock() {
            let _ = child.kill();
        }
    }
}

impl Drop for AgentProcess {
    fn drop(&mut self) {
        self.kill();
    }
}

fn claude_command(config: &LaunchConfig) -> Result<(PathBuf, Command)> {
    let (binary, mut command) = base_command(&config.instance)?;
    command
        .args([
            "-p",
            "--input-format",
            "stream-json",
            "--output-format",
            "stream-json",
            "--verbose",
            "--include-partial-messages",
            "--permission-prompt-tool",
            "stdio",
            // Lets the user switch to "Full access" at runtime.
            "--allow-dangerously-skip-permissions",
            "--permission-mode",
            config.permission_mode.as_cli(),
        ])
        .current_dir(&config.cwd);
    if let Some(model) = &config.model {
        command.args(["--model", model]);
    }
    if let Some(effort) = config.effort {
        command.args(["--effort", effort.as_cli()]);
    }
    if let Some(session_id) = &config.resume {
        command.args(["--resume", session_id]);
    }
    if let Some(window) = auto_compact_window(&config.instance.auto_compact) {
        command.args(["--settings", &format!(r#"{{"autoCompactWindow":{window}}}"#)]);
    }
    command.args(split_args(&config.instance.args));
    Ok((binary, command))
}

/// The "Auto-compact after" field as a token count, if it's one Claude
/// takes: 100,000 to 1,000,000.
pub fn auto_compact_window(text: &str) -> Option<u64> {
    let digits: String = text.chars().filter(|c| !matches!(c, ',' | '_' | ' ')).collect();
    digits.parse::<u64>().ok().filter(|tokens| (100_000..=1_000_000).contains(tokens))
}

fn pi_command(config: &LaunchConfig) -> Result<(PathBuf, Command)> {
    let (binary, mut command) = base_command(&config.instance)?;
    command.args(["--mode", "rpc"]).current_dir(&config.cwd);
    if let Some((provider, model)) = config.model.as_deref().and_then(|model| model.split_once('/')) {
        command.args(["--provider", provider, "--model", model]);
    }
    if let Some(effort) = config.effort {
        command.args(["--thinking", effort.as_cli()]);
    }
    if let Some(session) = &config.resume {
        command.args(["--session", session]);
    }
    command.args(split_args(&config.instance.args));
    Ok((binary, command))
}

/// The bridge to jcode's harness API on stdin and stdout. It starts jcode's
/// daemon if none is running; the thread then creates or attaches its
/// session over the API.
fn jcode_command(config: &LaunchConfig) -> Result<(PathBuf, Command)> {
    let (binary, mut command) = base_command(&config.instance)?;
    command.args(split_args(&config.instance.args));
    command.args(["--no-update", "api", "--stdio"]).current_dir(&config.cwd);
    Ok((binary, command))
}

/// The environment variable that moves an agent's home folder.
pub fn home_var(kind: Provider) -> &'static str {
    match kind {
        Provider::Claude => "CLAUDE_CONFIG_DIR",
        Provider::Pi => "PI_CODING_AGENT_DIR",
        Provider::Jcode => "JCODE_HOME",
    }
}

/// The variable that overrides the binary of an agent's first instance.
pub fn binary_var(kind: Provider) -> &'static str {
    match kind {
        Provider::Claude => "VECTRUM_CODE_CLAUDE_BIN",
        Provider::Pi => "VECTRUM_CODE_PI_BIN",
        Provider::Jcode => "VECTRUM_CODE_JCODE_BIN",
    }
}

/// A command for an agent's binary with the instance's home folder and
/// environment, and without the variables of any Claude session around us.
pub fn base_command(instance: &ProviderInstance) -> Result<(PathBuf, Command)> {
    let binary = find_binary(instance).ok_or_else(|| {
        anyhow!(
            "could not find the `{}` CLI on PATH (set its path in Settings → Providers)",
            instance.kind.key()
        )
    })?;
    let mut command = Command::new(&binary);
    for key in NESTED_SESSION_ENV {
        command.env_remove(key);
    }
    if !instance.home.trim().is_empty() {
        let home = expand_home(instance.home.trim());
        // jcode's daemon is found by its socket, which lives in the runtime
        // folder rather than the home; give each home its own daemon.
        if instance.kind == Provider::Jcode {
            let runtime = home.join("runtime");
            if std::fs::create_dir_all(&runtime).is_ok() {
                use std::os::unix::fs::PermissionsExt;
                let _ = std::fs::set_permissions(&runtime, std::fs::Permissions::from_mode(0o700));
                command.env("JCODE_RUNTIME_DIR", runtime);
            }
        }
        command.env(home_var(instance.kind), home);
    }
    for (key, value) in instance.env_vars() {
        command.env(key, value);
    }
    // Pi is a Node script; a desktop launcher's PATH may not reach the Node it
    // was installed with, which usually sits next to it.
    if instance.kind == Provider::Pi
        && let Some(dir) = binary.parent()
    {
        let path = std::env::var_os("PATH").unwrap_or_default();
        let paths = std::iter::once(dir.to_path_buf()).chain(std::env::split_paths(&path));
        if let Ok(joined) = std::env::join_paths(paths) {
            command.env("PATH", joined);
        }
    }
    Ok((binary, command))
}

/// Where an agent's binary is: the environment override (first instance
/// only), the instance's own path, then PATH and the usual install folders.
pub fn find_binary(instance: &ProviderInstance) -> Option<PathBuf> {
    if instance.id == instance.kind.key()
        && let Some(path) = std::env::var_os(binary_var(instance.kind))
    {
        return Some(PathBuf::from(path));
    }
    if !instance.binary.trim().is_empty() {
        return Some(expand_home(instance.binary.trim()));
    }
    let name = instance.kind.key();
    let on_path = std::env::var_os("PATH")
        .into_iter()
        .flat_map(|paths| std::env::split_paths(&paths).collect::<Vec<_>>())
        .map(|dir| dir.join(name));
    // Desktop launchers often start apps without the user's shell PATH.
    let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_default();
    let mut fallbacks = match instance.kind {
        Provider::Claude => vec![home.join(".local/bin/claude"), home.join(".claude/local/claude")],
        Provider::Pi => vec![
            home.join(".local/bin/pi"),
            home.join(".npm-global/bin/pi"),
            home.join(".bun/bin/pi"),
            home.join(".volta/bin/pi"),
        ],
        Provider::Jcode => vec![home.join(".local/bin/jcode"), home.join(".cargo/bin/jcode")],
    };
    fallbacks.extend([PathBuf::from("/usr/local/bin").join(name), PathBuf::from("/usr/bin").join(name)]);
    // nvm keeps one bin directory per Node version.
    if instance.kind == Provider::Pi
        && let Ok(versions) = std::fs::read_dir(home.join(".nvm/versions/node"))
    {
        fallbacks.extend(versions.flatten().map(|version| version.path().join("bin/pi")));
    }
    on_path.chain(fallbacks).find(|path| is_executable(path))
}

/// Splits launch arguments like a shell: on whitespace, keeping quoted runs
/// together.
pub fn split_args(text: &str) -> Vec<String> {
    let mut args = Vec::new();
    let mut current = String::new();
    let mut quote: Option<char> = None;
    let mut started = false;
    let mut chars = text.chars();
    while let Some(c) = chars.next() {
        match (quote, c) {
            (Some(q), c) if c == q => quote = None,
            (Some('"'), '\\') => current.extend(chars.next()),
            (Some(_), c) => current.push(c),
            (None, '"' | '\'') => {
                quote = Some(c);
                started = true;
            }
            (None, '\\') => {
                current.extend(chars.next());
                started = true;
            }
            (None, c) if c.is_whitespace() => {
                if started || !current.is_empty() {
                    args.push(std::mem::take(&mut current));
                }
                started = false;
            }
            (None, c) => {
                current.push(c);
                started = true;
            }
        }
    }
    if started || !current.is_empty() {
        args.push(current);
    }
    args
}

pub fn is_executable(path: &Path) -> bool {
    use std::os::unix::fs::PermissionsExt;
    path.metadata()
        .map(|meta| meta.is_file() && meta.permissions().mode() & 0o111 != 0)
        .unwrap_or(false)
}

#[cfg(test)]
mod tests {
    use super::{auto_compact_window, split_args};

    #[::core::prelude::v1::test]
    fn auto_compact_takes_claudes_range() {
        assert_eq!(auto_compact_window("300000"), Some(300_000));
        assert_eq!(auto_compact_window("1,000,000"), Some(1_000_000));
        assert_eq!(auto_compact_window("99999"), None);
        assert_eq!(auto_compact_window("2000000"), None);
        assert_eq!(auto_compact_window(""), None);
    }

    #[::core::prelude::v1::test]
    fn splits_like_a_shell() {
        assert_eq!(split_args(r#"--a 1 --b "two words" 'x y' z\ w"#), ["--a", "1", "--b", "two words", "x y", "z w"]);
        assert_eq!(split_args("  "), Vec::<String>::new());
        assert_eq!(split_args(r#"--empty """#), ["--empty", ""]);
    }
}