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()

}

/// the order `Service::commit` uses, the manifest saved with the blobs before `committed`

fn commit(index: &mut KeywordIndex, store: &mut BTreeMap<String, Vec<u8>>) {

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

    for key in &changes.deletes {

        store.remove(key);

    }

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

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

    }

    store.insert("meta".to_owned(), changes.manifest.to_string().into_bytes());

    index.committed(&changes);

}

fn reload(store: &BTreeMap<String, Vec<u8>>) -> KeywordIndex {

    let manifest: serde_json::Value = serde_json::from_slice(&store["meta"]).unwrap();

    KeywordIndex::load(&manifest, |key| store.get(key).cloned()).unwrap()

}

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

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

    let mut found: Vec<_> = keys(&hits).into_iter().map(str::to_owned).collect();

    found.sort();

    found

}

#[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!(found(&mut index, "before").is_empty());

    assert_eq!(found(&mut index, "after"), 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()

    );

}

#[test]

fn provisional_docs_stay_out_of_results() {

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

    let mut pending = doc(&provisional_key("$o", "@a:x"), "!r:x", 5, "early edit");

    pending.provisional = true;

    index.put(pending);

    assert!(found(&mut index, "early").is_empty());

    assert!(index.remove_provisional("$o"));

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

}

/// the manifest used to be read before `committed`, one commit stale, so a restart lost

/// the last flush and merge, and a bumped delete generation failed the whole load

#[test]

fn every_commit_reloads_to_what_was_committed() {

    let mut store = BTreeMap::new();

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

    let count = MERGE_FACTOR as u64 + 2;

    for ts in 0..count {

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

        commit(&mut index, &mut store);

        assert_eq!(found(&mut reload(&store), "kept").len(), ts as usize + 1);

    }

    index.remove("$e0");

    commit(&mut index, &mut store);

    index.remove("$e1");

    commit(&mut index, &mut store);

    index.put(doc("$e2", "!r:x", 2, "edited"));

    commit(&mut index, &mut store);

    let mut reloaded = reload(&store);

    let expected: Vec<String> = (3..count).map(|ts| format!("$e{ts}")).collect();

    assert_eq!(found(&mut reloaded, "kept"), expected);

    assert_eq!(found(&mut reloaded, "edited"), vec!["$e2"]);

    let mut referenced = reloaded.referenced();

    referenced.push("meta".to_owned());

    referenced.sort();

    let stored: Vec<_> = store.keys().cloned().collect();

    assert_eq!(stored, referenced, "a commit left blobs nothing points at");

}

#[test]

fn unspaced_text_matches_inside_a_run() {

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

    index.put(doc("$a", "!r:x", 1, "明日東京都庁に行きます"));

    assert_eq!(found(&mut index, "東京"), vec!["$a"]);

    assert_eq!(found(&mut index, "\"都庁\""), vec!["$a"]);

    assert!(found(&mut index, "大阪").is_empty());

}

#[test]

fn packed_segments_reject_truncation() {

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

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

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

}