//! `spectra mcp --auto` (spec §15.1): one MCP entry for every folder. The
//! shim speaks for the agent whose project folder the client started in,
//! from any depth inside it; an agent home made before labels is labelled
//! on first use; a folder with no agent gets a quiet server, not a failure.

mod common;

use common::{hermetic, run, setup, text, Serving};
use serde_json::{json, Value};
use std::io::{BufRead, BufReader, Write};
use std::path::Path;
use std::process::Stdio;

/// Run the shim in `cwd` and ask it two things: the handshake and `brief`.
fn ask(d: &Path, cwd: &Path) -> (Value, Value) {
    let mut c = hermetic(d)
        .args(["mcp", "--auto"])
        .current_dir(cwd)
        .env("SPECTRA_AGENTS", d.join("agents"))
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .unwrap();
    let mut stdin = c.stdin.take().unwrap();
    for v in [
        json!({ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "protocolVersion": "2025-06-18", "capabilities": {}, "clientInfo": { "name": "t", "version": "1" } } }),
        json!({ "jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": { "name": "brief", "arguments": {} } }),
    ] {
        writeln!(stdin, "{v}").unwrap();
    }
    stdin.flush().unwrap();
    let mut lines = BufReader::new(c.stdout.take().unwrap()).lines();
    let mut got = std::collections::HashMap::new();
    while got.len() < 2 {
        let v: Value = serde_json::from_str(&lines.next().unwrap().unwrap()).unwrap();
        got.insert(v["id"].as_u64().unwrap(), v);
    }
    drop(stdin);
    let _ = c.kill();
    let _ = c.wait();
    (got.remove(&1).unwrap(), got.remove(&2).unwrap())
}

#[test]
fn one_entry_serves_every_folder() {
    let dir = setup();
    let d = dir.path();
    for p in ["book", "web"] {
        std::fs::create_dir_all(d.join(p).join("chapters")).unwrap();
        assert!(run(d, &["project", "add", d.join(p).to_str().unwrap()]).status.success());
    }
    for (n, p) in [("claude-book", "book"), ("claude-web", "web")] {
        let home = d.join("agents").join(n);
        let o = run(d, &["agent", "add", n, "--kind", "claude-code", "--project", p, "--home", home.to_str().unwrap(), "--yes"]);
        assert!(o.status.success(), "{}", text(&o));
        assert!(home.join("agent.toml").exists(), "agent add labels the home");
    }
    // An agent home from before labels: labelled on first use.
    std::fs::remove_file(d.join("agents/claude-web/agent.toml")).unwrap();
    let srv = Serving::start(d);

    let (_, brief) = ask(d, &d.join("book/chapters"));
    assert!(brief["result"]["content"][0]["text"].as_str().unwrap().contains("You are claude-book"), "{brief}");
    let (_, brief) = ask(d, &d.join("web"));
    assert!(brief["result"]["content"][0]["text"].as_str().unwrap().contains("You are claude-web"), "{brief}");
    assert!(d.join("agents/claude-web/agent.toml").exists(), "labelled on first use");

    // Elsewhere: a quiet server that says how to join, not a failure.
    std::fs::create_dir_all(d.join("elsewhere")).unwrap();
    let (init, call) = ask(d, &d.join("elsewhere"));
    assert!(init["result"]["instructions"].as_str().unwrap().contains("has no Spectra agent"), "{init}");
    assert!(call["error"]["message"].as_str().unwrap().contains("Spectra: Add Agent"), "{call}");
    srv.stop();
}