macltok

use serde_json::json;

use super::*;

use crate::search::index::{KeywordIndex, provisional_key};

const ROOM: &str = "!room:x";

fn message(id: &str, sender: &str, ts: u64, body: &str) -> Value {

    json!({

        "type": "m.room.message",

        "event_id": id,

        "sender": sender,

        "origin_server_ts": ts,

        "content": { "msgtype": "m.text", "body": body },

    })

}

fn edit(id: &str, sender: &str, ts: u64, target: &str, body: &str) -> Value {

    json!({

        "type": "m.room.message",

        "event_id": id,

        "sender": sender,

        "origin_server_ts": ts,

        "content": {

            "msgtype": "m.text",

            "body": format!("* {body}"),

            "m.new_content": { "msgtype": "m.text", "body": body },

            "m.relates_to": { "rel_type": "m.replace", "event_id": target },

        },

    })

}

fn redaction(id: &str, target: &str) -> Value {

    json!({

        "type": "m.room.redaction",

        "event_id": id,

        "sender": "@a:x",

        "origin_server_ts": 99,

        "redacts": target,

        "content": {},

    })

}

fn feed(index: &mut KeywordIndex, redactions: &mut Redactions, value: Value) -> Effect {

    apply(index, redactions, ROOM, observe(&value))

}

fn keys(index: &mut KeywordIndex, query: &str) -> Vec<String> {

    let (hits, _) = index.search(query, None, None, 10).unwrap();

    hits.into_iter().map(|hit| hit.key).collect()

}

/// backfill walks newest first, so an edit routinely lands before what it edits

#[test]

fn an_edit_before_its_original_keeps_the_edit_and_takes_the_original_timestamp() {

    let mut index = KeywordIndex::new(false);

    let mut redactions = Redactions::default();

    feed(

        &mut index,

        &mut redactions,

        edit("$e", "@a:x", 20, "$o", "fixed words"),

    );

    let provisional = index.get(&provisional_key("$o", "@a:x")).unwrap();

    assert!(provisional.provisional);

    assert_eq!(provisional.ts, 20);

    assert!(keys(&mut index, "fixed").is_empty());

    feed(

        &mut index,

        &mut redactions,

        message("$o", "@a:x", 10, "typo wrds"),

    );

    let doc = index.get("$o").unwrap();

    assert!(!doc.provisional);

    assert_eq!((doc.ts, doc.content.as_str()), (10, "$e"));

    assert_eq!(keys(&mut index, "fixed"), vec!["$o"]);

    assert!(keys(&mut index, "wrds").is_empty());

}

#[test]

fn edits_from_someone_else_and_older_edits_lose() {

    let mut index = KeywordIndex::new(false);

    let mut redactions = Redactions::default();

    feed(

        &mut index,

        &mut redactions,

        message("$o", "@a:x", 10, "original"),

    );

    feed(

        &mut index,

        &mut redactions,

        edit("$e2", "@a:x", 30, "$o", "newest"),

    );

    assert_eq!(

        feed(

            &mut index,

            &mut redactions,

            edit("$e1", "@a:x", 20, "$o", "older")

        ),

        Effect::Nothing

    );

    assert_eq!(

        feed(

            &mut index,

            &mut redactions,

            edit("$h", "@b:x", 40, "$o", "hijack")

        ),

        Effect::Nothing

    );

    assert_eq!(keys(&mut index, "newest"), vec!["$o"]);

    assert!(keys(&mut index, "hijack").is_empty());

    assert!(keys(&mut index, "original").is_empty());

}

#[test]

fn a_provisional_edit_from_someone_else_gives_way_to_the_original() {

    let mut index = KeywordIndex::new(false);

    let mut redactions = Redactions::default();

    feed(

        &mut index,

        &mut redactions,

        edit("$h", "@b:x", 20, "$o", "hijack"),

    );

    feed(

        &mut index,

        &mut redactions,

        message("$o", "@a:x", 10, "genuine"),

    );

    assert_eq!(keys(&mut index, "genuine"), vec!["$o"]);

    assert!(keys(&mut index, "hijack").is_empty());

}

#[test]

fn a_redaction_removes_the_message_and_a_stale_copy_cannot_bring_it_back() {

    let mut index = KeywordIndex::new(false);

    let mut redactions = Redactions::default();

    feed(

        &mut index,

        &mut redactions,

        message("$o", "@a:x", 10, "secret"),

    );

    assert_eq!(

        feed(&mut index, &mut redactions, redaction("$r", "$o")),

        Effect::Removed

    );

    feed(

        &mut index,

        &mut redactions,

        message("$o", "@a:x", 10, "secret"),

    );

    assert!(keys(&mut index, "secret").is_empty());

}

#[test]

fn redacting_the_latest_edit_asks_for_the_original_again() {

    let mut index = KeywordIndex::new(false);

    let mut redactions = Redactions::default();

    feed(

        &mut index,

        &mut redactions,

        message("$o", "@a:x", 10, "first"),

    );

    feed(

        &mut index,

        &mut redactions,

        edit("$e", "@a:x", 20, "$o", "second"),

    );

    assert_eq!(

        feed(&mut index, &mut redactions, redaction("$r", "$e")),

        Effect::Refetch("$o".to_owned())

    );

    let mut original = message("$o", "@a:x", 10, "first");

    original["unsigned"] =

        json!({ "m.relations": { "m.replace": edit("$e", "@a:x", 20, "$o", "second") } });

    feed(&mut index, &mut redactions, original);

    assert_eq!(keys(&mut index, "first"), vec!["$o"]);

    assert!(keys(&mut index, "second").is_empty());

}

#[test]

fn reply_fallbacks_are_not_indexed() {

    let mut index = KeywordIndex::new(false);

    let mut redactions = Redactions::default();

    let mut reply = message("$r", "@a:x", 10, "> <@b:x> quoted stuff\n\nactual answer");

    reply["content"]["m.relates_to"] = json!({ "m.in_reply_to": { "event_id": "$q" } });

    feed(&mut index, &mut redactions, reply);

    assert_eq!(keys(&mut index, "answer"), vec!["$r"]);

    assert!(keys(&mut index, "quoted").is_empty());

}

#[test]

fn a_strangers_early_edit_cannot_shut_out_the_author() {

    let mut index = KeywordIndex::new(false);

    let mut redactions = Redactions::default();

    feed(

        &mut index,

        &mut redactions,

        edit("$h", "@b:x", 30, "$o", "hijack"),

    );

    feed(

        &mut index,

        &mut redactions,

        edit("$e", "@a:x", 20, "$o", "genuine edit"),

    );

    feed(

        &mut index,

        &mut redactions,

        message("$o", "@a:x", 10, "original"),

    );

    assert_eq!(keys(&mut index, "genuine"), vec!["$o"]);

    assert!(keys(&mut index, "hijack").is_empty());

    assert!(index.get(&provisional_key("$o", "@b:x")).is_none());

}

#[test]

fn an_edit_of_an_edit_is_ignored() {

    let mut index = KeywordIndex::new(false);

    let mut redactions = Redactions::default();

    feed(

        &mut index,

        &mut redactions,

        message("$o", "@a:x", 10, "original"),

    );

    feed(

        &mut index,

        &mut redactions,

        edit("$e", "@a:x", 20, "$o", "first"),

    );

    assert_eq!(

        feed(

            &mut index,

            &mut redactions,

            edit("$ee", "@a:x", 30, "$e", "nested")

        ),

        Effect::Nothing

    );

    assert!(index.get(&provisional_key("$e", "@a:x")).is_none());

}

#[test]

fn an_edit_to_unreadable_content_clears_the_old_text() {

    let mut index = KeywordIndex::new(false);

    let mut redactions = Redactions::default();

    feed(

        &mut index,

        &mut redactions,

        message("$o", "@a:x", 10, "secret plans"),

    );

    let mut blank = edit("$e", "@a:x", 20, "$o", "x");

    blank["content"]["m.new_content"] = json!({ "msgtype": "m.unknown" });

    feed(&mut index, &mut redactions, blank);

    assert!(keys(&mut index, "secret").is_empty());

}