//! `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");

    }

}