//! Conversation (spec §10, §13.1): who may post where, threads, mentions

//! and direct messages into the inbox, duplicates, limits, redaction, and

//! search limited to what the reader may see.

mod common;

use common::World;

use spectra_core::conversation::{self as conv, Post, Posted};

use spectra_core::ids::now_ms;

fn post(body: &str) -> Post {

    Post { body: body.into(), ..Default::default() }

}

fn id(p: Posted) -> String {

    match p {

        Posted::Message { id, .. } => id,

        Posted::Duplicate { id } => panic!("dropped as a duplicate of {id}"),

    }

}

#[tokio::test]

async fn agents_post_where_they_belong_and_nowhere_else() {

    let mut w = World::new(&["oxygen", "oxygenhub"]).await;

    let claude = w.agent("claude-oxygen", "oxygen").await;

    let a = w.author(&claude).await;

    let at = conv::post(&w.ledger, &a, post("default goes to my project"), now_ms()).await.unwrap();

    assert!(matches!(&at, Posted::Message { channel, .. } if channel == "#oxygen"), "{at:?}");

    for c in ["general", "humans", "#oxygen"] {

        conv::post(&w.ledger, &a, Post { channel: Some(c.into()), ..post(&format!("hello {c}")) }, now_ms()).await.unwrap();

    }

    for (c, why) in [("oxygenhub", "another project"), ("system", "Spectra's")] {

        let err = conv::post(&w.ledger, &a, Post { channel: Some(c.into()), ..post("nope") }, now_ms()).await.unwrap_err();

        assert!(err.to_string().contains(why), "{c}: {err}");

    }

    let owner_pair = w.owner.clone();

    let owner = w.author(&owner_pair).await;

    conv::post(&w.ledger, &owner, Post { channel: Some("oxygenhub".into()), ..post("the owner posts anywhere but #system") }, now_ms())

        .await

        .unwrap();

    w.verify_clean().await;

}

#[tokio::test]

async fn threads_mentions_and_direct_messages_reach_the_inbox() {

    let mut w = World::new(&["oxygen", "oxygenhub"]).await;

    let claude = w.agent("claude-oxygen", "oxygen").await;

    let kimi = w.agent("kimi-hub", "oxygenhub").await;

    let (c, k) = (w.author(&claude).await, w.author(&kimi).await);

    let root = id(conv::post(

        &w.ledger,

        &c,

        Post { channel: Some("general".into()), ..post("@kimi-hub the wire protocol grew a field; see oxy:change:abcdef12") },

        now_ms(),

    )

    .await

    .unwrap());

    let items = conv::inbox(&w.ledger, "agent:kimi-hub", Some(&k)).await.unwrap();

    assert_eq!(items.len(), 1);

    assert_eq!((items[0].kind.as_str(), items[0].from.as_str(), items[0].channel.as_str()), ("mention", "agent:claude-oxygen", "#general"));

    let reply = id(conv::post(&w.ledger, &k, Post { reply_to: Some(root.clone()), ..post("@andy should I bump the pin?") }, now_ms())

        .await

        .unwrap());

    let nested =

        id(conv::post(&w.ledger, &c, Post { reply_to: Some(reply.clone()), ..post("yes, after the release") }, now_ms()).await.unwrap());

    let (_, thread) = conv::read(&w.ledger, &c.principal, None, Some(&nested), None, 50).await.unwrap();

    assert_eq!(

        thread.iter().map(|m| m.id.clone()).collect::<Vec<_>>(),

        [root.clone(), reply.clone(), nested],

        "a reply to a reply joins the root's thread"

    );

    let (_, roots) = conv::read(&w.ledger, &c.principal, Some("general"), None, None, 50).await.unwrap();

    assert_eq!(roots.len(), 1);

    assert_eq!(roots[0].replies, 2);

    assert_eq!(conv::unread(&w.ledger, "human").await.unwrap(), 1, "@andy is the owner");

    assert_eq!(conv::ack(&w.ledger, &k, std::slice::from_ref(&root), Some("ack")).await.unwrap(), 1);

    assert!(conv::inbox(&w.ledger, "agent:kimi-hub", None).await.unwrap().is_empty());

    let dm = conv::ensure_direct(&w.ledger, &c.principal, "kimi-hub").await.unwrap();

    assert_eq!(dm.display(), "@claude-oxygen+kimi-hub");

    conv::post(&w.ledger, &c, Post { channel: Some(dm.name.clone()), ..post("just between us") }, now_ms()).await.unwrap();

    assert_eq!(conv::inbox(&w.ledger, "agent:kimi-hub", None).await.unwrap()[0].kind, "dm");

    let third = w.agent("third", "oxygen").await;

    let t = w.author(&third).await;

    assert!(conv::read(&w.ledger, &t.principal, Some(&dm.name), None, None, 10).await.is_err(), "not a member");

    assert!(conv::post(&w.ledger, &t, Post { channel: Some(dm.name.clone()), ..post("let me in") }, now_ms()).await.is_err());

    w.verify_clean().await;

}

#[tokio::test]

async fn duplicates_limits_and_redaction() {

    let mut w = World::new(&["oxygen"]).await;

    let claude = w.agent("claude-oxygen", "oxygen").await;

    let c = w.author(&claude).await;

    let first = id(conv::post(&w.ledger, &c, post("build failed on main"), now_ms()).await.unwrap());

    assert!(

        matches!(conv::post(&w.ledger, &c, post("build failed on main"), now_ms()).await.unwrap(), Posted::Duplicate { id } if id == first)

    );

    assert!(conv::post(&w.ledger, &c, post(&"x".repeat(conv::MAX_BODY + 1)), now_ms()).await.is_err());

    assert!(conv::post(&w.ledger, &c, post("   "), now_ms()).await.is_err());

    assert!(conv::post(&w.ledger, &c, Post { kind: Some("shout".into()), ..post("x") }, now_ms()).await.is_err());

    let secret = id(conv::post(&w.ledger, &c, post("the token is hunter2"), now_ms()).await.unwrap());

    assert_eq!(conv::search(&w.ledger, &c.principal, "hunter2", None, None, None, 10).await.unwrap().len(), 1);

    let kimi = w.agent("kimi", "oxygen").await;

    let k = w.author(&kimi).await;

    assert!(conv::redact(&w.ledger, &k, &secret, "not mine").await.is_err(), "only its author or the owner");

    conv::redact(&w.ledger, &c, &secret, "a secret pasted by mistake").await.unwrap();

    let (_, msgs) = conv::read(&w.ledger, &c.principal, None, None, None, 10).await.unwrap();

    let shown = msgs.iter().find(|m| m.id == secret).unwrap();

    assert_eq!(shown.body, "[redacted: a secret pasted by mistake]");

    assert!(conv::search(&w.ledger, &c.principal, "hunter2", None, None, None, 10).await.unwrap().is_empty(), "gone from search");

    w.verify_clean().await;

}

#[tokio::test]

async fn search_finds_stemmed_words_and_respects_who_may_read() {

    let mut w = World::new(&["oxygen"]).await;

    let claude = w.agent("claude-oxygen", "oxygen").await;

    let kimi = w.agent("kimi", "oxygen").await;

    let (c, k) = (w.author(&claude).await, w.author(&kimi).await);

    conv::post(

        &w.ledger,

        &c,

        Post { channel: Some("general".into()), ..post("We decided to bump the oxygen pin after releasing 0.11") },

        now_ms(),

    )

    .await

    .unwrap();

    conv::post(&w.ledger, &c, post("Unrelated chatter about lunch"), now_ms()).await.unwrap();

    let dm = conv::ensure_direct(&w.ledger, &c.principal, "human").await.unwrap();

    conv::post(&w.ledger, &c, Post { channel: Some(dm.name.clone()), ..post("privately: the pin bump worries me") }, now_ms())

        .await

        .unwrap();

    let hits = conv::search(&w.ledger, &k.principal, "bumping pins", None, None, None, 20).await.unwrap();

    assert_eq!(hits.len(), 1, "stemmed, and the direct message is not kimi's to see: {hits:?}");

    assert!(hits[0].snippet.contains("[bump]"), "{}", hits[0].snippet);

    assert_eq!(hits[0].channel, "#general");

    let owner_pair = w.owner.clone();

    let owner = w.author(&owner_pair).await;

    assert_eq!(

        conv::search(&w.ledger, &owner.principal, "pin", None, None, None, 20).await.unwrap().len(),

        2,

        "the owner reads everything"

    );

    assert_eq!(

        conv::search(&w.ledger, &k.principal, "\"oxygen pin\"", Some("general"), Some("claude-oxygen"), None, 20).await.unwrap().len(),

        1

    );

    assert!(conv::search(&w.ledger, &k.principal, "lunch", Some("general"), None, None, 20).await.unwrap().is_empty());

    let err = conv::search(&w.ledger, &k.principal, "AND OR (", None, None, None, 20).await.unwrap_err();

    assert!(err.to_string().contains("does not parse"), "{err}");

    w.verify_clean().await;

}