//! The stdio shim, `spectra mcp --agent NAME` (spec §15.1), driven over
//! pipes as a client would: the handshake, tools, concurrency (a `wait` in
//! flight does not hold up other requests), nothing but protocol on stdout,
//! and plain answers when the daemon is not running.

mod common;

use common::{add_agent, hermetic, setup, Serving};
use serde_json::{json, Value};
use spectra_mcp::client::Client;
use std::process::Stdio;
use std::time::Duration;
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, Lines};
use tokio::process::{ChildStdin, ChildStdout};

struct Shim {
    child: tokio::process::Child,
    stdin: ChildStdin,
    stdout: Lines<BufReader<ChildStdout>>,
}

impl Shim {
    fn start(d: &std::path::Path, agent: &str, extra: &[&str]) -> Shim {
        let mut cmd = tokio::process::Command::from(hermetic(d));
        cmd.args(["mcp", "--agent", agent])
            .args(extra)
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .kill_on_drop(true);
        let mut child = cmd.spawn().unwrap();
        let stdin = child.stdin.take().unwrap();
        let stdout = BufReader::new(child.stdout.take().unwrap()).lines();
        Shim { child, stdin, stdout }
    }
    async fn send(&mut self, v: Value) {
        self.stdin.write_all(format!("{v}\n").as_bytes()).await.unwrap();
        self.stdin.flush().await.unwrap();
    }
    async fn recv(&mut self) -> Value {
        let line = tokio::time::timeout(Duration::from_secs(20), self.stdout.next_line())
            .await
            .expect("an answer within 20 s")
            .unwrap()
            .expect("a line");
        serde_json::from_str(&line).unwrap_or_else(|e| panic!("stdout carries only JSON-RPC, got {line:?}: {e}"))
    }
}

fn call(id: u64, name: &str, args: Value) -> Value {
    json!({ "jsonrpc": "2.0", "id": id, "method": "tools/call", "params": { "name": name, "arguments": args } })
}

#[tokio::test]
async fn a_client_speaks_to_spectra_through_the_shim() {
    let dir = setup();
    let d = dir.path();
    add_agent(d, "claude-oxygen", &[]);
    let kimi = add_agent(d, "kimi-oxygen", &[]);
    let srv = Serving::start(d);
    let mut s = Shim::start(d, "claude-oxygen", &[]);

    s.send(json!({ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "protocolVersion": "2025-06-18", "capabilities": {}, "clientInfo": { "name": "test", "version": "1" } } })).await;
    let init = s.recv().await;
    assert_eq!(init["result"]["protocolVersion"], "2025-06-18");
    s.send(json!({ "jsonrpc": "2.0", "method": "notifications/initialized" })).await;
    s.send(json!({ "jsonrpc": "2.0", "id": 2, "method": "tools/list" })).await;
    let list = s.recv().await;
    assert_eq!(list["id"], 2, "a notification gets no answer");
    assert_eq!(list["result"]["tools"].as_array().unwrap().len(), 11);
    s.send(call(3, "brief", json!({}))).await;
    let brief = s.recv().await;
    assert!(brief["result"]["content"][0]["text"].as_str().unwrap().contains("You are claude-oxygen · Andy McCall's agent"));

    // A wait in flight, then another request: the second is answered first.
    s.send(call(10, "wait", json!({ "timeout_s": 15 }))).await;
    tokio::time::sleep(Duration::from_millis(200)).await;
    s.send(json!({ "jsonrpc": "2.0", "id": 11, "method": "ping" })).await;
    assert_eq!(s.recv().await["id"], 11, "ping is not held up by the wait");
    let k = Client::new(&srv.socket, Some(kimi));
    let say = json!({ "jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": { "name": "say", "arguments": { "body": "@claude-oxygen ready when you are", "channel": "general" } } });
    assert_eq!(k.mcp("2025-11-25", &say).await.unwrap().status, 200);
    let woke = s.recv().await;
    assert_eq!(woke["id"], 10);
    assert!(woke["result"]["content"][0]["text"].as_str().unwrap().contains("ready when you are"), "{woke}");

    drop(s);
    srv.stop();
}

#[tokio::test]
async fn the_shim_says_plainly_what_is_wrong() {
    let dir = setup();
    let d = dir.path();
    add_agent(d, "claude-oxygen", &[]);
    add_agent(d, "kimi-oxygen", &[]);

    // No daemon: an answer, not silence.
    let mut s = Shim::start(d, "claude-oxygen", &[]);
    s.send(json!({ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "protocolVersion": "2025-11-25" } })).await;
    let r = s.recv().await;
    assert!(r["error"]["message"].as_str().unwrap().contains("spectra serve"), "{r}");
    drop(s);

    let out = hermetic(d).args(["mcp", "--agent", "nobody"]).stdin(Stdio::null()).output().unwrap();
    assert!(!out.status.success() && String::from_utf8_lossy(&out.stderr).contains("no agent named nobody"));
    assert!(out.stdout.is_empty(), "errors never go to stdout");
    let other = d.join("agents/kimi-oxygen");
    let out =
        hermetic(d).args(["mcp", "--agent", "claude-oxygen", "--home", other.to_str().unwrap()]).stdin(Stdio::null()).output().unwrap();
    assert!(
        !out.status.success() && String::from_utf8_lossy(&out.stderr).contains("holds kimi-oxygen's key"),
        "{}",
        String::from_utf8_lossy(&out.stderr)
    );
}