macltok

use std::collections::BTreeMap;

use super::*;

fn doc(key: &str, room: &str, ts: u64, text: &str) -> Doc {

    Doc {

        key: key.to_owned(),

        room: room.to_owned(),

        sender: "@a:x".to_owned(),

        ts,

        content: key.to_owned(),

        content_ts: ts,

        text: text.to_owned(),

        provisional: false,

    }

}

fn keys(hits: &[Hit]) -> Vec<&str> {

    hits.iter().map(|hit| hit.key.as_str()).collect()

}

fn commit(index: &mut KeywordIndex, blobs: &mut BTreeMap<String, Vec<u8>>) -> serde_json::Value {

    let changes = index.changes().unwrap();

    for key in &changes.deletes {

        blobs.remove(key);

    }

    for (key, value) in &changes.puts {

        blobs.insert(key.clone(), value.clone());

    }

    index.committed(&changes);

    index.manifest()

}

#[test]

fn pages_run_newest_first_without_repeats_across_segments() {

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

    for ts in 0..30 {

        index.put(doc(&format!("$e{ts}"), "!r:x", ts, "hello there"));

        if ts % 7 == 0 {

            index.maintain().unwrap();

        }

    }

    let mut seen = Vec::new();

    let mut before = None;

    loop {

        let (hits, _) = index.search("hello", None, before, 8).unwrap();

        let Some(last) = hits.last() else { break };

        before = Some((last.ts, last.tie));

        seen.extend(hits.iter().map(|hit| hit.ts));

    }

    assert_eq!(seen, (0..30).rev().collect::<Vec<_>>());

}

#[test]

fn a_replaced_doc_is_found_once_by_its_new_text() {

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

    index.put(doc("$a", "!r:x", 1, "before"));

    index.maintain().unwrap();

    index.put(doc("$a", "!r:x", 1, "after"));

    assert!(index.search("before", None, None, 10).unwrap().0.is_empty());

    assert_eq!(

        keys(&index.search("after", None, None, 10).unwrap().0),

        vec!["$a"]

    );

}

#[test]

fn rooms_filter_the_results() {

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

    index.put(doc("$a", "!one:x", 1, "word"));

    index.put(doc("$b", "!two:x", 2, "word"));

    let rooms = vec!["!one:x".to_owned()];

    assert_eq!(

        keys(&index.search("word", Some(&rooms), None, 10).unwrap().0),

        vec!["$a"]

    );

    assert!(

        index

            .search("word", Some(&[]), None, 10)

            .unwrap()

            .0

            .is_empty()

    );

}

/// a lost delete brings a redacted message back, and a lost segment loses messages

#[test]

fn deletes_and_merges_survive_a_reload() {

    let mut blobs = BTreeMap::new();

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

    for ts in 0..(MERGE_FACTOR as u64 + 2) {

        index.put(doc(&format!("$e{ts}"), "!r:x", ts, "kept"));

        commit(&mut index, &mut blobs);

    }

    index.put(doc("$gone", "!r:x", 100, "kept"));

    commit(&mut index, &mut blobs);

    index.remove("$gone");

    index.remove("$e0");

    let manifest = commit(&mut index, &mut blobs);

    let mut reloaded = KeywordIndex::load(&manifest, |key| blobs.get(key).cloned()).unwrap();

    let (hits, _) = reloaded.search("kept", None, None, 50).unwrap();

    let mut found = keys(&hits);

    found.sort();

    let mut expected: Vec<String> = (1..(MERGE_FACTOR as u64 + 2))

        .map(|ts| format!("$e{ts}"))

        .collect();

    expected.sort();

    assert_eq!(

        found,

        expected.iter().map(String::as_str).collect::<Vec<_>>()

    );

    let referenced: Vec<_> = blobs.keys().filter(|key| key.starts_with("seg/")).collect();

    assert!(

        referenced.len() < MERGE_FACTOR,

        "merged segments were not dropped: {referenced:?}"

    );

}

#[test]

fn match_ranges_follow_the_analyser() {

    assert_eq!(

        match_ranges("Café, CAFE and cafés", &["cafe".to_owned()]),

        vec![(0, 5), (7, 11)]

    );

}

#[test]

fn packed_segments_reject_truncation() {

    let packed = pack(&[("a".to_owned(), vec![1, 2, 3])]);

    assert!(unpack(&packed).is_some());

    assert!(unpack(&packed[..packed.len() - 1]).is_none());

}