//! The targets of spec §24, measured: `brief` and `say` with a thousand
//! messages in the ledger, and how soon `wait` wakes after a mention. Run
//! in release, by hand:
//!
//! `cargo test --release --test bench -- --ignored --nocapture`

mod common;

use common::{add_agent, setup, Serving};
use serde_json::json;
use spectra_mcp::client::{rpc_result, Client};
use std::time::{Duration, Instant};

async fn call(c: &Client, name: &str, args: serde_json::Value) -> serde_json::Value {
    let req = json!({ "jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": { "name": name, "arguments": args } });
    rpc_result(&c.mcp("2025-11-25", &req).await.unwrap()).unwrap()
}

fn median(mut v: Vec<Duration>) -> Duration {
    v.sort();
    v[v.len() / 2]
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[ignore]
async fn spec_24_targets() {
    let dir = setup();
    let d = dir.path();
    let a = add_agent(d, "bench-a", &[]);
    let b = add_agent(d, "bench-b", &[]);
    let srv = Serving::start(d);
    let (ca, cb) = (Client::new(&srv.socket, Some(a)), Client::new(&srv.socket, Some(b)));
    for i in 0..1_000 {
        call(&ca, "say", json!({ "body": format!("message {i} about the pin bump"), "channel": "general" })).await;
    }
    let mut brief = Vec::new();
    let mut say = Vec::new();
    for i in 0..50 {
        let t = Instant::now();
        call(&ca, "brief", json!({})).await;
        brief.push(t.elapsed());
        let t = Instant::now();
        call(&ca, "say", json!({ "body": format!("timed {i}") })).await;
        say.push(t.elapsed());
    }
    let mut wake = Vec::new();
    for i in 0..10 {
        let w = tokio::spawn({
            let cb = Client::new(&srv.socket, Some(spectra_core::keys::KeyPair::load_home(&d.join("agents/bench-b")).unwrap()));
            async move {
                call(&cb, "wait", json!({ "timeout_s": 20 })).await;
                Instant::now()
            }
        });
        tokio::time::sleep(Duration::from_millis(200)).await;
        let sent = Instant::now();
        call(&ca, "say", json!({ "body": format!("@bench-b wake {i}"), "channel": "general" })).await;
        wake.push(w.await.unwrap().saturating_duration_since(sent));
        call(&cb, "ack", json!({ "ids": [] })).await;
        let inbox = call(&cb, "inbox", json!({})).await;
        let ids: Vec<serde_json::Value> =
            inbox["result"]["structuredContent"]["items"].as_array().unwrap().iter().map(|i| i["id"].clone()).collect();
        call(&cb, "ack", json!({ "ids": ids })).await;
    }
    println!("spec §24 with 1,000 messages, round trip over the socket including signing:");
    println!("  brief  median {:?}", median(brief));
    println!("  say    median {:?}", median(say));
    println!("  wait   wakes {:?} after the mention is sent (median)", median(wake));
    srv.stop();
}