//! The JSON API (spec §18) against the real daemon: every endpoint, signed

//! by an agent and by the owner; problems for refusals; paging; ETags; the

//! event log as the owner's; and the live stream.

mod common;

use common::{add_agent, setup, Serving};

use serde_json::{json, Value};

use spectra_core::keys::KeyPair;

use spectra_mcp::client::Client;

async fn get(c: &Client, path: &str) -> Value {

    let r = c.send("GET", path, &[], vec![]).await.unwrap();

    assert_eq!(r.status, 200, "{path}: {}", String::from_utf8_lossy(&r.body));

    r.json().unwrap()

}

#[tokio::test]

async fn every_endpoint_for_an_agent_and_the_owner() {

    let dir = setup();

    let d = dir.path();

    let claude = add_agent(d, "claude-oxygen", &[]);

    let srv = Serving::start(d);

    let a = Client::new(&srv.socket, Some(claude));

    let owner = Client::new(&srv.socket, Some(KeyPair::load_home(&d.join("owner")).unwrap()));

    let anon = Client::new(&srv.socket, None);

    assert_eq!(get(&anon, "/api/v1/health").await["ok"], true);

    assert_eq!(get(&anon, "/api/v1/version").await["ledger_format"], 1);

    let r = anon.send("GET", "/api/v1/agents", &[], vec![]).await.unwrap();

    assert_eq!(r.status, 401);

    assert_eq!(r.header("content-type"), Some("application/problem+json"));

    assert_eq!(r.json().unwrap()["status"], 401);

    let b = get(&a, "/api/v1/brief").await;

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

    assert_eq!(b["project"], "oxygen");

    assert_eq!(get(&a, "/api/v1/agents").await[0]["display"], "claude-oxygen · Andy McCall's agent");

    assert_eq!(get(&a, "/api/v1/projects").await[0]["name"], "oxygen");

    let chans = get(&a, "/api/v1/channels").await;

    assert!(chans.as_array().unwrap().iter().any(|c| c["display"] == "#general"));

    // Post, page, and read a thread.

    let mut first = String::new();

    for i in 0..5 {

        let r = a

            .send(

                "POST",

                "/api/v1/channels/general/messages",

                &[],

                serde_json::to_vec(&json!({ "body": format!("note {i} for @andy") })).unwrap(),

            )

            .await

            .unwrap();

        assert_eq!(r.status, 201, "{}", String::from_utf8_lossy(&r.body));

        if i == 0 {

            first = r.json().unwrap()["id"].as_str().unwrap().to_string();

        }

    }

    let p1 = get(&a, "/api/v1/channels/general/messages?limit=2").await;

    assert_eq!(p1["items"].as_array().unwrap().len(), 2);

    let r = a

        .send(

            "POST",

            "/api/v1/channels/general/messages",

            &[],

            serde_json::to_vec(&json!({ "body": "a reply", "reply_to": first })).unwrap(),

        )

        .await

        .unwrap();

    assert_eq!(r.status, 201);

    let t = get(&a, &format!("/api/v1/threads/{first}")).await;

    assert_eq!(t["items"].as_array().unwrap().len(), 2);

    let r = a.send("POST", "/api/v1/channels/system/messages", &[], serde_json::to_vec(&json!({ "body": "x" })).unwrap()).await.unwrap();

    assert_eq!((r.status, r.json().unwrap()["status"].as_u64()), (400, Some(400)), "#system refuses, as a problem");

    // The owner's inbox, acked; search.

    let inbox = get(&owner, "/api/v1/inbox").await;

    assert_eq!(inbox.as_array().unwrap().len(), 5);

    let ids: Vec<Value> = inbox.as_array().unwrap().iter().map(|i| i["id"].clone()).collect();

    let r = owner.send("POST", "/api/v1/inbox/ack", &[], serde_json::to_vec(&json!({ "ids": ids })).unwrap()).await.unwrap();

    assert_eq!(r.json().unwrap()["read"], 5);

    assert_eq!(get(&owner, "/api/v1/inbox").await.as_array().unwrap().len(), 0);

    assert_eq!(get(&a, "/api/v1/search?q=note&limit=3").await.as_array().unwrap().len(), 3);

    // ETags: the same answer twice is a 304.

    let r = a.send("GET", "/api/v1/projects", &[], vec![]).await.unwrap();

    let tag = r.header("etag").unwrap().to_string();

    assert_eq!(a.send("GET", "/api/v1/projects", &[("if-none-match", tag)], vec![]).await.unwrap().status, 304);

    // The log is the owner's; it pages; the stream follows.

    assert_eq!(a.send("GET", "/api/v1/events", &[], vec![]).await.unwrap().status, 403);

    let ev = get(&owner, "/api/v1/events?limit=5").await;

    assert_eq!(ev["items"][0]["kind"], "identity.owner");

    assert_eq!(ev["next"], 5);

    let posted = get(&owner, "/api/v1/events?kind=message.posted&limit=50").await;

    assert_eq!(posted["items"].as_array().unwrap().len(), 6);

    assert!(posted["items"].as_array().unwrap().iter().all(|e| e["method"] == "signature" && e["assurance"] == 2));

    let stream = tokio::spawn({

        let owner = Client::new(&srv.socket, Some(KeyPair::load_home(&d.join("owner")).unwrap()));

        async move { owner.send("GET", "/api/v1/events?follow=1&max=1&kind=message.posted", &[], vec![]).await.unwrap() }

    });

    tokio::time::sleep(std::time::Duration::from_millis(300)).await;

    a.send("POST", "/api/v1/channels/general/messages", &[], serde_json::to_vec(&json!({ "body": "streamed" })).unwrap()).await.unwrap();

    let s = tokio::time::timeout(std::time::Duration::from_secs(10), stream).await.expect("the stream ends after max events").unwrap();

    assert!(String::from_utf8_lossy(&s.body).contains("\"kind\":\"message.posted\""), "{}", String::from_utf8_lossy(&s.body));

    srv.stop();

}