//! The whole command line from a workstation (spec §8.6, spectra#21 and

//! #23): the daemon on one machine, the owner, their agents and every

//! command on another, with no ledger file on the workstation at all.

mod common;

use common::{add_agent, delegate, hermetic, run, text, Serving};

use serde_json::{json, Value};

use spectra_core::keys::KeyPair;

use std::path::Path;

use std::process::Stdio;

use std::time::Duration;

use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};

fn json_of(d: &Path, args: &[&str]) -> Value {

    let o = run(d, args);

    assert!(o.status.success(), "{args:?}: {}", text(&o));

    serde_json::from_slice(&o.stdout)

        .unwrap_or_else(|e| panic!("{args:?}: one JSON document ({e}): {}", String::from_utf8_lossy(&o.stdout)))

}

/// A server in `s`, claimed by the owner whose home is `c/owner`.

fn connected(s: &Path, c: &Path) -> (Serving, u16) {

    KeyPair::create_home(&c.join("owner"), "Andy McCall", "").unwrap();

    let owner = KeyPair::load_home(&c.join("owner")).unwrap();

    assert!(run(s, &["init", "--owner", &owner.key.to_hex(), "--name", "earth"]).status.success());

    let (srv, port) = Serving::start_tls(s);

    let url = format!("https://127.0.0.1:{port}");

    assert_eq!(run(c, &["connect", &url]).status.code(), Some(1));

    delegate(&c.join("owner"), &KeyPair::instance(&s.join("data"), "earth").unwrap());

    let o = run(c, &["connect", &url]);

    assert!(o.status.success(), "{}", text(&o));

    (srv, port)

}

#[tokio::test]

async fn every_command_works_from_another_machine() {

    let (sd, cd) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());

    let (s, c) = (sd.path(), cd.path());

    let (srv, _port) = connected(s, c);

    std::fs::create_dir_all(c.join("oxygen")).unwrap();

    let o = run(c, &["project", "add", c.join("oxygen").to_str().unwrap()]);

    assert!(o.status.success(), "{}", text(&o));

    add_agent(c, "claude-oxygen", &[]);

    add_agent(c, "spare", &[]);

    let id = json_of(c, &["identity", "show", "--json"]);

    assert_eq!(id["instance"]["name"], "earth");

    assert_eq!(id["instance"]["delegated"], true, "{id}");

    let agents = json_of(c, &["agent", "list", "--json"]);

    let claude = agents.as_array().unwrap().iter().find(|a| a["name"] == "claude-oxygen").unwrap();

    assert_eq!(claude["state"], "ok", "{claude}");

    assert_eq!(claude["display"], "claude-oxygen · Andy McCall's agent");

    let projects = json_of(c, &["project", "list", "--json"]);

    assert_eq!(projects[0]["name"], "oxygen");

    assert!(projects[0]["agents"].as_array().unwrap().contains(&json!("claude-oxygen")));

    let o = run(c, &["agent", "disable", "spare"]);

    assert!(o.status.success(), "{}", text(&o));

    assert_eq!(json_of(c, &["say", "--json", "-c", "general", "the release is tomorrow"])["channel"], "#general");

    assert!(json_of(c, &["inbox", "--json"]).is_array());

    assert_eq!(json_of(c, &["search", "--json", "release"]).as_array().unwrap().len(), 1);

    let brief: Value = serde_json::from_slice(&run(c, &["api", "GET", "/api/v1/brief"]).stdout).unwrap();

    assert_eq!(brief["actor"], "human");

    // An agent's shim on the workstation talks to the server.

    let mut cmd = tokio::process::Command::from(hermetic(c));

    let home = c.join("agents/claude-oxygen");

    cmd.args(["mcp", "--agent", "claude-oxygen", "--home", home.to_str().unwrap()])

        .stdin(Stdio::piped())

        .stdout(Stdio::piped())

        .stderr(Stdio::piped())

        .kill_on_drop(true);

    let mut shim = cmd.spawn().unwrap();

    let mut stdin = shim.stdin.take().unwrap();

    let mut lines = BufReader::new(shim.stdout.take().unwrap()).lines();

    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": {} } }),

    ] {

        stdin.write_all(format!("{v}\n").as_bytes()).await.unwrap();

    }

    stdin.flush().await.unwrap();

    let mut brief = Value::Null;

    for _ in 0..2 {

        let line = tokio::time::timeout(Duration::from_secs(20), lines.next_line()).await.unwrap().unwrap().unwrap();

        let v: Value = serde_json::from_str(&line).unwrap();

        if v["id"] == 2 {

            brief = v;

        }

    }

    assert!(brief["result"]["content"][0]["text"].as_str().unwrap().contains("You are claude-oxygen · Andy McCall's agent"), "{brief}");

    drop(shim);

    // The ledger stays on the server: verify asks it; check and rebuild refuse here.

    let v = json_of(c, &["admin", "verify", "--json"]);

    assert!(v["findings"].as_array().unwrap().is_empty(), "{v}");

    let o = run(c, &["admin", "check"]);

    assert!(!o.status.success() && text(&o).contains("runs on the server"), "{}", text(&o));

    assert!(!c.join("data").exists(), "the workstation has no data directory");

    srv.stop();

    let o = run(s, &["admin", "verify"]);

    assert!(o.status.success(), "{}", text(&o));

}