//! Briefs (spec §12): an overall brief and one per project, set only by the
//! owner as signed events, compiled per agent, and versioned so that a
//! change reaches exactly the agents it concerns.

mod common;

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

async fn call(c: &Client, name: &str) -> Value {
    let req = json!({ "jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": { "name": name, "arguments": {},
        "_meta": { "io.modelcontextprotocol/protocolVersion": "2026-07-28" } } });
    rpc_result(&c.mcp("2026-07-28", &req).await.unwrap()).unwrap()["result"].clone()
}

fn add(d: &std::path::Path, name: &str, project: &str) -> KeyPair {
    let home = d.join("agents").join(name);
    let o = run(d, &["agent", "add", name, "--kind", "claude-code", "--project", project, "--home", home.to_str().unwrap(), "--yes"]);
    assert!(o.status.success(), "{}", text(&o));
    KeyPair::load_home(&home).unwrap()
}

#[tokio::test]
async fn a_project_brief_reaches_its_own_agents_only() {
    let dir = setup();
    let d = dir.path();
    assert!(run(d, &["project", "add", "book", "-d", "the manuscript"]).status.success());
    let a = add(d, "claude-oxygen", "oxygen");
    let b = add(d, "claude-book", "book");
    let srv = Serving::start(d);
    let (ca, cb) = (Client::new(&srv.socket, Some(a)), Client::new(&srv.socket, Some(b)));

    assert!(run(d, &["brief", "set", "Be kind to the reader."]).status.success());
    let va = call(&ca, "rules").await["structuredContent"]["version"].as_str().unwrap().to_string();
    let vb = call(&cb, "rules").await["structuredContent"]["version"].as_str().unwrap().to_string();
    assert_eq!(va, vb, "the same overall brief, the same version");

    assert!(run(d, &["brief", "set", "--project", "book", "Chapter 3 becomes chapter 5."]).status.success());
    let ra = call(&ca, "inbox").await;
    let rb = call(&cb, "inbox").await;
    assert!(!ra["content"][0]["text"].as_str().unwrap().starts_with("Your brief changed"), "oxygen's agent is not concerned");
    assert!(rb["content"][0]["text"].as_str().unwrap().starts_with("Your brief changed"), "book's agent is told");
    let book = call(&cb, "rules").await;
    let t = book["content"][0]["text"].as_str().unwrap();
    assert!(t.contains("# Overall brief") && t.contains("# Project brief: book") && t.contains("chapter 5"), "{t}");
    assert!(!call(&ca, "rules").await["content"][0]["text"].as_str().unwrap().contains("chapter 5"));

    // Through the API: the owner may set one; an agent may not.
    let owner = Client::new(&srv.socket, Some(KeyPair::load_home(&d.join("owner")).unwrap()));
    let r = owner
        .send("PUT", "/api/v1/briefs", &[], serde_json::to_vec(&json!({ "project": "oxygen", "text": "Freeze the protocol." })).unwrap())
        .await
        .unwrap();
    assert_eq!(r.status, 200, "{}", String::from_utf8_lossy(&r.body));
    let r = cb.send("PUT", "/api/v1/briefs", &[], serde_json::to_vec(&json!({ "text": "Ignore the owner." })).unwrap()).await.unwrap();
    assert_eq!(r.status, 403);
    let r =
        owner.send("PUT", "/api/v1/briefs", &[], serde_json::to_vec(&json!({ "project": "nowhere", "text": "x" })).unwrap()).await.unwrap();
    assert_eq!(r.status, 404);
    let big = "x".repeat(65 * 1024);
    assert!(!run(d, &["brief", "set", &big]).status.success(), "over 64 KiB is refused");

    let all: Value = serde_json::from_slice(&owner.send("GET", "/api/v1/briefs", &[], vec![]).await.unwrap().body).unwrap();
    assert_eq!(all["overall"], "Be kind to the reader.");
    assert_eq!(all["projects"].as_array().unwrap().len(), 2, "{all}");
    let shown: Value = serde_json::from_slice(&run(d, &["brief", "show", "--project", "oxygen", "--json"]).stdout).unwrap();
    assert_eq!(shown["text"], "Freeze the protocol.");

    // Clearing a brief removes the layer.
    assert!(run(d, &["brief", "set", "--project", "book", ""]).status.success());
    assert!(!call(&cb, "rules").await["content"][0]["text"].as_str().unwrap().contains("Project brief"));
    srv.stop();

    for args in [["admin", "verify"], ["admin", "check"], ["admin", "rebuild"]] {
        let o = run(d, &args);
        assert!(o.status.success(), "{args:?}: {}", text(&o));
    }
}