//! `spectra mcp --auto` (spec §15.1): one MCP entry for every folder. The
//! shim finds the agent for the folder its client started in, from the
//! agent homes under `$SPECTRA_AGENTS` (else `~/.spectra-agents`), each of
//! which `spectra agent add` labels with an `agent.toml` naming the
//! agent, its kind, its project and the project's folder. Each folder
//! still signs as its own agent. A folder with no agent gets a quiet
//! server that says how to add one, instead of a failure.

use anyhow::{Context, Result};
use serde_json::{json, Value as Json};
use spectra_core::keys::KeyPair;
use spectra_mcp::client::Client;
use std::path::{Path, PathBuf};
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};

/// What `agent add` writes into an agent's home.
#[derive(Clone, Debug)]
pub struct Label {
    pub name: String,
    pub kind: String,
    pub folder: Option<PathBuf>,
    pub home: PathBuf,
}

pub fn agents_dir() -> PathBuf {
    if let Some(d) = std::env::var_os("SPECTRA_AGENTS").filter(|d| !d.is_empty()) {
        return PathBuf::from(d);
    }
    std::env::var_os("HOME").map(PathBuf::from).unwrap_or_default().join(".spectra-agents")
}

pub fn write_label(home: &Path, name: &str, kind: &str, project: &str, folder: Option<&str>) -> Result<()> {
    let mut t = toml::Table::new();
    t.insert("name".into(), name.into());
    t.insert("kind".into(), kind.into());
    t.insert("project".into(), project.into());
    if let Some(f) = folder.filter(|f| !f.is_empty()) {
        t.insert("folder".into(), f.into());
    }
    let text = format!("# Written by `spectra agent add`: lets `spectra mcp --auto` find this agent.\n{t}");
    spectra_core::durable::write_atomic(&home.join("agent.toml"), text.as_bytes())?;
    Ok(())
}

fn read_label(home: &Path) -> Option<Label> {
    let t: toml::Table = std::fs::read_to_string(home.join("agent.toml")).ok()?.parse().ok()?;
    let s = |k: &str| t.get(k).and_then(|v| v.as_str()).map(String::from);
    s("project")?;
    Some(Label { name: s("name")?, kind: s("kind")?, folder: s("folder").map(PathBuf::from), home: home.to_path_buf() })
}

/// Label an agent home made before labels existed, by asking Spectra (as
/// that agent) which project it works on and where the project lives.
async fn learn_label(endpoint: &spectra_mcp::client::Endpoint, home: &Path) -> Option<Label> {
    let key = KeyPair::load_home(home).ok()?;
    let c = Client::at(endpoint.clone(), Some(key.clone()));
    let agents = c.send("GET", "/api/v1/agents", &[], vec![]).await.ok()?.json().ok()?;
    let me = agents.as_array()?.iter().find(|a| a["key"] == key.key.to_hex())?.clone();
    let projects = c.send("GET", "/api/v1/projects", &[], vec![]).await.ok()?.json().ok()?;
    let project = me["project"].as_str()?.to_string();
    let folder = projects.as_array()?.iter().find(|p| p["name"] == project.as_str()).and_then(|p| p["path"].as_str().map(String::from));
    let (name, kind) = (me["name"].as_str()?.to_string(), me["kind"].as_str()?.to_string());
    let _ = write_label(home, &name, &kind, &project, folder.as_deref());
    Some(Label { name, kind, folder: folder.map(PathBuf::from), home: home.to_path_buf() })
}

/// Every labelled agent home, labelling older ones on the way.
pub async fn labels(endpoint: Option<&spectra_mcp::client::Endpoint>) -> Vec<Label> {
    let mut out = Vec::new();
    let Ok(dirs) = std::fs::read_dir(agents_dir()) else { return out };
    for d in dirs.filter_map(|e| e.ok()).map(|e| e.path()).filter(|p| p.join("keys").is_dir()) {
        match read_label(&d) {
            Some(l) => out.push(l),
            None => {
                if let Some(ep) = endpoint {
                    if let Some(l) = learn_label(ep, &d).await {
                        out.push(l);
                    }
                }
            }
        }
    }
    out
}

/// The agent of `kind` for `cwd`: the one whose project folder holds it,
/// the deepest folder first, then by name.
pub fn choose<'a>(labels: &'a [Label], cwd: &Path, kind: &str) -> Option<&'a Label> {
    let cwd = cwd.canonicalize().unwrap_or_else(|_| cwd.to_path_buf());
    labels
        .iter()
        .filter(|l| l.kind == kind)
        .filter_map(|l| {
            let f = l.folder.as_ref()?;
            let f = f.canonicalize().unwrap_or_else(|_| f.clone());
            cwd.starts_with(&f).then(|| (f.components().count(), l))
        })
        .max_by(|(a, x), (b, y)| a.cmp(b).then_with(|| y.name.cmp(&x.name)))
        .map(|(_, l)| l)
}

/// The quiet server for a folder with no agent: it answers the handshake,
/// lists no tools, and its instructions say how to join.
pub async fn unconnected(cwd: &Path, kind: &str) -> Result<i32> {
    let why = format!(
        "This folder ({}) has no Spectra agent of kind {kind}, so Spectra's tools are not available here. \
         The owner can add one with the Spectra VS Code extension (Spectra: Add Agent) or with \
         `spectra agent add NAME --kind {kind} --project PROJECT --home ~/.spectra-agents/NAME`, \
         after `spectra project add {}`; then start a new session.",
        cwd.display(),
        cwd.display()
    );
    let mut out = tokio::io::stdout();
    let mut lines = BufReader::new(tokio::io::stdin()).lines();
    while let Some(line) = lines.next_line().await? {
        let Ok(req) = serde_json::from_str::<Json>(&line) else { continue };
        let Some(id) = req.get("id").cloned() else { continue };
        let result = match req.get("method").and_then(Json::as_str).unwrap_or("") {
            "initialize" => {
                let v = req.pointer("/params/protocolVersion").and_then(Json::as_str).unwrap_or(super::mcp::STDIO_VERSIONS[0]);
                let v = if super::mcp::STDIO_VERSIONS.contains(&v) { v } else { super::mcp::STDIO_VERSIONS[0] };
                json!({ "protocolVersion": v, "capabilities": { "tools": {} }, "serverInfo": { "name": "spectra", "version": env!("CARGO_PKG_VERSION") }, "instructions": why })
            }
            "tools/list" => json!({ "tools": [] }),
            "ping" => json!({}),
            _ => {
                let e = json!({ "jsonrpc": "2.0", "id": id, "error": { "code": -32601, "message": why } });
                out.write_all(format!("{e}\n").as_bytes()).await?;
                out.flush().await?;
                continue;
            }
        };
        out.write_all(format!("{}\n", json!({ "jsonrpc": "2.0", "id": id, "result": result })).as_bytes()).await?;
        out.flush().await?;
    }
    Ok(0)
}

/// Resolve the agent for this session's folder, or None.
pub async fn resolve(ctx: &super::Ctx, kind: &str) -> Result<Option<Label>> {
    let cwd = std::env::current_dir().context("this session's folder")?;
    let endpoint = ctx.endpoint().ok();
    let all = labels(endpoint.as_ref()).await;
    Ok(choose(&all, &cwd, kind).cloned())
}

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

    fn l(name: &str, kind: &str, folder: &str) -> Label {
        Label { name: name.into(), kind: kind.into(), folder: Some(PathBuf::from(folder)), home: PathBuf::new() }
    }

    #[test]
    fn the_deepest_folder_of_the_right_kind_wins() {
        let all = [
            l("claude-dev", "claude-code", "/dev"),
            l("claude-book", "claude-code", "/dev/book"),
            l("kimi-book", "kimi-code", "/dev/book"),
        ];
        assert_eq!(choose(&all, Path::new("/dev/book/ch3"), "claude-code").unwrap().name, "claude-book");
        assert_eq!(choose(&all, Path::new("/dev/other"), "claude-code").unwrap().name, "claude-dev");
        assert_eq!(choose(&all, Path::new("/dev/book"), "kimi-code").unwrap().name, "kimi-book");
        assert!(choose(&all, Path::new("/elsewhere"), "claude-code").is_none());
        assert!(choose(&all, Path::new("/devx"), "claude-code").is_none(), "a prefix of the name is not inside");
    }
}