//! Who may act as whom (spec §5.2 G1, G7; §8): an agent is its owner's

//! delegate or nothing, may not act in another's name, stops when its

//! delegation expires or is disabled, and a request is refused unless

//! signed, fresh, unreplayed and from the bound Unix user.

use spectra_core::authn::{Authenticator, Refusal};

use spectra_core::event::NewEvent;

use spectra_core::identity::{Delegate, Identity};

use spectra_core::ids::now_ms;

use spectra_core::keys::KeyPair;

use spectra_core::ledger::{Ledger, Problem};

use spectra_core::principals::{identity_payload, signed_event, Principal, Principals};

use spectra_core::proof::Proof;

use std::path::Path;

/// The owner delegates to `agent`: a successor with the same key pair,

/// made current in the owner's home. Only the owner's own tools do this.

fn delegate(owner_home: &Path, agent: &Identity, expires: Option<u64>) -> KeyPair {

    spectra_core::keys::delegate(owner_home, agent.hash(), expires).unwrap()

}

struct World {

    _dir: tempfile::TempDir,

    owner_home: std::path::PathBuf,

    ledger: Ledger,

    owner: KeyPair,

}

async fn world() -> World {

    let dir = tempfile::tempdir().unwrap();

    let owner_home = dir.path().join("owner");

    let owner = KeyPair::create_home(&owner_home, "Andy McCall", "[email protected]").unwrap();

    let data = dir.path().join("data");

    std::fs::create_dir_all(&data).unwrap();

    let instance = KeyPair::instance(&data, "laptop").unwrap();

    let ledger = Ledger::open(&data.join("spectra.db"), Some(instance.clone())).await.unwrap();

    ledger.append_one(signed_event(&owner, "human", "identity.owner", identity_payload(&owner.identity))).await.unwrap();

    ledger.append_one(signed_event(&instance, "system", "identity.instance", identity_payload(&instance.identity))).await.unwrap();

    World { _dir: dir, owner_home, ledger, owner }

}

/// Add `name` as the owner would: delegate, record the successor, add.

async fn add_agent(w: &mut World, name: &str, expires: Option<u64>) -> KeyPair {

    let agent = KeyPair::generate(name, "");

    let prev = w.owner.identity.clone();

    w.owner = delegate(&w.owner_home, &agent.identity, expires);

    let mut rotated = identity_payload(&w.owner.identity);

    rotated["chain"] = serde_json::json!([]);

    assert_eq!(w.owner.identity.previous, Some(prev.hash()));

    w.ledger.append_one(signed_event(&w.owner, "human", "identity.rotated", rotated)).await.unwrap();

    let mut p = identity_payload(&agent.identity);

    p["name"] = name.into();

    p["kind"] = "claude-code".into();

    p["project"] = "oxygen".into();

    p["owner"] = w.owner.key.to_hex().into();

    p["owner_name"] = "Andy McCall".into();

    w.ledger.append_one(signed_event(&w.owner, "human", "agent.added", p)).await.unwrap();

    agent

}

fn said(agent: &KeyPair, actor: &str, body: &str) -> NewEvent {

    signed_event(agent, actor, "message.posted", serde_json::json!({ "body": body }))

}

#[tokio::test]

async fn an_owned_agent_acts_and_the_ledger_verifies_every_signature() {

    let mut w = world().await;

    let a = add_agent(&mut w, "claude-oxygen", None).await;

    w.ledger.append_one(said(&a, "agent:claude-oxygen", "hello")).await.unwrap();

    w.ledger.checkpoint().await.unwrap();

    let mut p = Principals::default();

    let v = w.ledger.verify(&mut p).await.unwrap();

    assert!(v.clean(), "{:?}", v.findings);

    let who = p.principal(&a.key, now_ms()).unwrap();

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

    // The projection agrees, and so does a fresh load.

    assert!(w.ledger.check().await.unwrap().is_empty());

    let loaded = Principals::load(&w.ledger).await.unwrap();

    assert!(matches!(loaded.principal(&a.key, now_ms()), Ok(Principal::Agent { .. })));

}

#[tokio::test]

async fn an_agent_without_the_owners_delegation_cannot_be_added() {

    let w = world().await;

    let stray = KeyPair::generate("stray", "");

    let mut p = identity_payload(&stray.identity);

    p["name"] = "stray".into();

    p["project"] = "oxygen".into();

    w.ledger.append_one(signed_event(&w.owner, "human", "agent.added", p)).await.unwrap();

    w.ledger.append_one(said(&stray, "agent:stray", "I am somebody's")).await.unwrap();

    let v = w.ledger.verify(&mut Principals::default()).await.unwrap();

    let bad: Vec<_> = v.findings.iter().filter(|f| f.problem == Problem::BadProof).collect();

    assert_eq!(bad.len(), 2, "the addition and the message: {:?}", v.findings);

    assert!(bad[0].detail.contains("without the owner's delegation"), "{}", bad[0].detail);

}

#[tokio::test]

async fn an_agent_cannot_act_in_another_agents_name_or_the_owners() {

    let mut w = world().await;

    let a = add_agent(&mut w, "claude-oxygen", None).await;

    let _b = add_agent(&mut w, "antigravity-hub", None).await;

    w.ledger.append_one(said(&a, "agent:antigravity-hub", "I am antigravity")).await.unwrap();

    w.ledger.append_one(said(&a, "human", "I am Andy")).await.unwrap();

    let v = w.ledger.verify(&mut Principals::default()).await.unwrap();

    assert_eq!(v.findings.len(), 2, "{:?}", v.findings);

    assert!(v.findings.iter().all(|f| f.detail.contains("is signed by claude-oxygen")));

}

#[tokio::test]

async fn an_agent_cannot_record_itself_as_the_owner_or_a_successor() {

    let mut w = world().await;

    let a = add_agent(&mut w, "claude-oxygen", None).await;

    // A successor of the owner that the agent made: it has no owner key to sign it with.

    let forged = w.owner.identity.successor(vec![Delegate { key: a.key, expires: None }], None, now_ms());

    let mut p = identity_payload(&forged);

    p["chain"] = serde_json::json!([]);

    w.ledger.append_one(signed_event(&a, "human", "identity.rotated", p)).await.unwrap();

    // And a second owner, signed by itself.

    w.ledger.append_one(signed_event(&a, "human", "identity.owner", identity_payload(&a.identity))).await.unwrap();

    let v = w.ledger.verify(&mut Principals::default()).await.unwrap();

    assert_eq!(v.findings.len(), 2, "{:?}", v.findings);

}

#[tokio::test]

async fn an_expired_or_disabled_agent_is_refused_and_flagged() {

    let mut w = world().await;

    let a = add_agent(&mut w, "overnight", Some(now_ms() + 60_000)).await;

    let principals = Principals::load(&w.ledger).await.unwrap();

    assert!(principals.principal(&a.key, now_ms()).is_ok());

    let later = now_ms() + 120_000;

    let why = principals.principal(&a.key, later).unwrap_err();

    assert!(why.contains("expired"), "{why}");

    let b = add_agent(&mut w, "claude-oxygen", None).await;

    w.ledger.append_one(signed_event(&w.owner, "human", "agent.disabled", serde_json::json!({ "name": "claude-oxygen" }))).await.unwrap();

    w.ledger.append_one(said(&b, "agent:claude-oxygen", "still here?")).await.unwrap();

    let v = w.ledger.verify(&mut Principals::default()).await.unwrap();

    assert_eq!(v.findings.len(), 1, "{:?}", v.findings);

    assert!(v.findings[0].detail.contains("disabled"));

}

#[tokio::test]

async fn a_proof_swapped_from_another_event_is_caught() {

    let mut w = world().await;

    let a = add_agent(&mut w, "claude-oxygen", None).await;

    let first = w.ledger.append_one(said(&a, "agent:claude-oxygen", "one")).await.unwrap();

    let second = w.ledger.append_one(said(&a, "agent:claude-oxygen", "two")).await.unwrap();

    let pool = w.ledger.pool().clone();

    sqlx::query("UPDATE events SET auth_proof = ? WHERE seq = ?")

        .bind(first.auth.proof.clone())

        .bind(second.seq as i64)

        .execute(&pool)

        .await

        .unwrap();

    let v = w.ledger.verify(&mut Principals::default()).await.unwrap();

    assert_eq!(v.findings.len(), 1, "{:?}", v.findings);

    assert!(v.findings[0].detail.contains("different body"));

}

#[tokio::test]

async fn requests_are_refused_unless_signed_fresh_unreplayed_and_from_the_bound_uid() {

    let mut w = world().await;

    let a = add_agent(&mut w, "claude-oxygen", None).await;

    let principals = Principals::load(&w.ledger).await.unwrap();

    let auth = Authenticator::default();

    let now = now_ms();

    let body = br#"{"jsonrpc":"2.0","id":1,"method":"tools/list"}"#;

    assert_eq!(auth.authenticate(&principals, None, "POST /mcp", body, now, Some(1000)).unwrap_err(), Refusal::Unsigned);

    let good = Proof::sign(&a, "POST /mcp", body);

    let caller = auth.authenticate(&principals, Some(&good), "POST /mcp", body, now, Some(1000)).unwrap();

    assert_eq!(caller.principal.actor(), "agent:claude-oxygen");

    assert_eq!(caller.auth.assurance, 2);

    assert_eq!(auth.authenticate(&principals, Some(&good), "POST /mcp", body, now, Some(1000)).unwrap_err(), Refusal::Replay);

    let other_body = Proof::sign(&a, "POST /mcp", body);

    assert!(matches!(auth.authenticate(&principals, Some(&other_body), "POST /mcp", b"{}", now, None), Err(Refusal::BadSignature(_))));

    let old = Proof::sign_at(&a, "POST /mcp", body, now - 10 * 60_000, [7; 16]);

    assert!(matches!(auth.authenticate(&principals, Some(&old), "POST /mcp", body, now, None), Err(Refusal::Stale(_))));

    let wrong = Proof::sign(&a, "POST /api/v1/channels", body);

    assert!(matches!(auth.authenticate(&principals, Some(&wrong), "POST /mcp", body, now, None), Err(Refusal::WrongMethod(_))));

    let stranger = KeyPair::generate("stranger", "");

    assert!(matches!(

        auth.authenticate(&principals, Some(&Proof::sign(&stranger, "POST /mcp", body)), "POST /mcp", body, now, None),

        Err(Refusal::NotAPrincipal(_))

    ));

    let owner = auth.authenticate(&principals, Some(&Proof::sign(&w.owner, "POST /mcp", body)), "POST /mcp", body, now, None).unwrap();

    assert_eq!(owner.principal.actor(), "human");

    // An agent bound to a Unix user, used from another.

    let b = add_agent_bound(&mut w, "bound", 1001).await;

    let principals = Principals::load(&w.ledger).await.unwrap();

    let r = auth.authenticate(&principals, Some(&Proof::sign(&b, "POST /mcp", body)), "POST /mcp", body, now, Some(1000));

    assert_eq!(r.unwrap_err(), Refusal::WrongUid { agent: "bound".into(), bound: 1001, from: 1000 });

    assert!(auth.authenticate(&principals, Some(&Proof::sign(&b, "POST /mcp", body)), "POST /mcp", body, now, Some(1001)).is_ok());

}

async fn add_agent_bound(w: &mut World, name: &str, uid: u32) -> KeyPair {

    let agent = KeyPair::generate(name, "");

    w.owner = delegate(&w.owner_home, &agent.identity, None);

    let mut rotated = identity_payload(&w.owner.identity);

    rotated["chain"] = serde_json::json!([]);

    w.ledger.append_one(signed_event(&w.owner, "human", "identity.rotated", rotated)).await.unwrap();

    let mut p = identity_payload(&agent.identity);

    p["name"] = name.into();

    p["project"] = "oxygen".into();

    p["uid"] = uid.into();

    w.ledger.append_one(signed_event(&w.owner, "human", "agent.added", p)).await.unwrap();

    agent

}

#[tokio::test]

async fn an_unsigned_claim_to_be_the_owner_or_an_agent_never_reaches_the_tables() {

    let w = world().await;

    let fake = KeyPair::generate("mallory", "");

    let mut p = identity_payload(&fake.identity);

    p["name"] = "mallory".into();

    p["project"] = "oxygen".into();

    w.ledger.append_one(NewEvent::system("agent.added", p)).await.unwrap();

    w.ledger.append_one(NewEvent::system("identity.rotated", identity_payload(&fake.identity))).await.unwrap();

    let agents: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM agents").fetch_one(w.ledger.pool()).await.unwrap();

    let owners: Vec<String> =

        sqlx::query_scalar("SELECT name FROM identities WHERE role = 'owner' AND current = 1").fetch_all(w.ledger.pool()).await.unwrap();

    assert_eq!(agents, 0);

    assert_eq!(owners, ["Andy McCall"]);

    let v = w.ledger.verify(&mut Principals::default()).await.unwrap();

    assert_eq!(v.findings.len(), 2, "both are reported: {:?}", v.findings);

}