//! The daemon over TLS (spec §8.6, spectra#20): a certificate of its own,
//! vouched for by the instance key; a client that trusts that, and only
//! that; signed MCP calls over the network; no uid-bound agent over TCP.

mod common;

use common::{add_agent, run, setup, text, Serving};
use serde_json::json;
use spectra_core::keys::KeyPair;
use spectra_mcp::client::{rpc_result, Client, Endpoint};
use spectra_mcp::tls::Pinned;

fn unpinned(port: u16) -> (Client, std::sync::Arc<Pinned>) {
    let v = Pinned::new(None);
    let e = Endpoint::Tls { addr: format!("127.0.0.1:{port}"), config: v.client_config().unwrap() };
    (Client::at(e, None), v)
}

#[tokio::test]
async fn a_client_trusts_the_certificate_the_instance_key_signed() {
    let dir = setup();
    let d = dir.path();
    let agent = add_agent(d, "claude-oxygen", &[]);
    let (srv, port) = Serving::start_tls(d);

    // Unauthenticated, before trusting anything: who is this?
    let (c, seen) = unpinned(port);
    let r = c.send("GET", "/api/v1/instance", &[], vec![]).await.unwrap();
    assert_eq!(r.status, 200, "{}", String::from_utf8_lossy(&r.body));
    let answer = r.json().unwrap();
    let (_, pin) = seen.seen().expect("the handshake showed a certificate");
    let checked = spectra_mcp::instance::check(&answer, &pin).unwrap();
    let instance = KeyPair::instance(&d.join("data"), "spectra").unwrap();
    assert_eq!(checked.instance.hash(), instance.key, "the instance key vouches for the certificate");
    let owner = KeyPair::load_home(&d.join("owner")).unwrap();
    assert_eq!(checked.owner.as_deref(), Some(owner.key.to_hex().as_str()));

    // A certificate the instance did not sign is not accepted.
    assert!(spectra_mcp::instance::check(&answer, &[7; 32]).is_err());

    // Pinned, an agent's signed MCP call works over the network.
    let c = Client::at(Endpoint::tls(&format!("https://127.0.0.1:{port}"), pin).unwrap(), Some(agent));
    let call = json!({ "jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": { "name": "agents", "arguments": {},
        "_meta": { "io.modelcontextprotocol/protocolVersion": "2026-07-28" } } });
    let r = c.mcp("2026-07-28", &call).await.unwrap();
    let v = rpc_result(&r).unwrap();
    assert_eq!(v["result"]["isError"], false, "{v}");
    assert!(v["result"]["content"][0]["text"].as_str().unwrap().contains("claude-oxygen · Andy McCall's agent"));

    // Any other certificate is refused at the handshake.
    let wrong = Client::at(Endpoint::tls(&format!("https://127.0.0.1:{port}"), [0; 32]).unwrap(), None);
    assert!(wrong.send("GET", "/api/v1/instance", &[], vec![]).await.is_err());
    srv.stop();

    // The certificate is kept, and recorded once, across restarts; verify
    // checks the instance's signature on it.
    let (srv, port2) = Serving::start_tls(d);
    let (c, seen) = unpinned(port2);
    c.send("GET", "/api/v1/instance", &[], vec![]).await.unwrap();
    assert_eq!(seen.seen().unwrap().1, pin);
    srv.stop();
    let o = run(d, &["admin", "verify"]);
    assert!(o.status.success(), "{}", text(&o));
}

#[tokio::test]
async fn an_agent_bound_to_a_uid_is_refused_over_the_network() {
    let dir = setup();
    let d = dir.path();
    let uid = unsafe { libc::getuid() }.to_string();
    let bound = add_agent(d, "bound", &["--uid", &uid]);
    let (srv, port) = Serving::start_tls(d);
    let (probe, seen) = unpinned(port);
    probe.send("GET", "/api/v1/instance", &[], vec![]).await.unwrap();
    let pin = seen.seen().unwrap().1;
    let c = Client::at(Endpoint::tls(&format!("https://127.0.0.1:{port}"), pin).unwrap(), Some(bound.clone()));
    let r = c.mcp("2026-07-28", &json!({ "jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {} })).await.unwrap();
    assert_eq!(r.status, 401);
    assert!(String::from_utf8_lossy(&r.body).contains("must come over the Unix socket"), "{}", String::from_utf8_lossy(&r.body));
    // Over the socket, from its own uid, it is welcome.
    let local = Client::new(&srv.socket, Some(bound));
    let r = local.mcp("2026-07-28", &json!({ "jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {} })).await.unwrap();
    assert_eq!(r.status, 200);
    srv.stop();
    let o = run(d, &["admin", "verify"]);
    assert!(o.status.success(), "{}", text(&o));
    let log = spectra_core::ledger::Ledger::open_read_only(&d.join("data/spectra.db")).await.unwrap();
    let g = log.events_of_kinds(1, &["guard.impersonation"], 10).await.unwrap();
    assert_eq!(g.len(), 1, "recorded as an impersonation attempt");
}

#[test]
fn plain_http_beyond_loopback_is_refused() {
    let dir = setup();
    let o = run(dir.path(), &["serve", "--bind", "0.0.0.0:0", "--tls", "off"]);
    assert!(!o.status.success());
    assert!(text(&o).contains("over TLS only"), "{}", text(&o));
}