macltok

use ruma::{event_id, user_id};

use super::state::{Data, SavedEvent, Window, id};

use crate::{

    MentionCaptureState, MentionEntry, MentionKey, MentionReason, Message, MessageKind, SendState,

    Sender, TimelineContent, TimelineEvent, TimelineItem, TimelineItemId,

};

fn key(room: &str, event: &str) -> MentionKey {

    MentionKey {

        room_id: format!("!{room}:mentions.example").parse().unwrap(),

        event_id: format!("${event}:mentions.example").parse().unwrap(),

    }

}

fn entry(key: MentionKey, timestamp_ms: u64, discovery_revision: u64, read: bool) -> MentionEntry {

    MentionEntry {

        key,

        timestamp_ms,

        discovered_at_ms: timestamp_ms,

        discovery_revision,

        revision: discovery_revision,

        event: TimelineItem::DayDivider { timestamp_ms },

        reasons: vec![MentionReason::Direct],

        read,

        capture: MentionCaptureState::Ready,

        room_name: None,

        notification_suppressed: false,

    }

}

fn message_event(event_id: &str, timestamp_ms: u64, body: &str) -> TimelineItem {

    let event_id: ruma::OwnedEventId = event_id.parse().unwrap();

    TimelineItem::Event(Box::new(TimelineEvent {

        item_id: TimelineItemId::new(format!("item-{event_id}")),

        event_id: Some(event_id),

        transaction_id: None,

        sender: Sender {

            user_id: user_id!("@bob:mentions.example").to_owned(),

            display_name: Some("Bob".to_owned()),

            avatar: None,

            name_ambiguous: false,

        },

        timestamp_ms,

        own: false,

        send_state: SendState::Sent,

        content: TimelineContent::Message(Message {

            kind: MessageKind::Text,

            body: body.to_owned(),

            geo_uri: None,

            formatted_body: None,

            mentions: None,

            edited: false,

            media: None,

            link_previews: Vec::new(),

        }),

        reply_to: None,

        thread_root: None,

        thread_summary: None,

        reactions: Vec::new(),

        read_by: Vec::new(),

        editable: false,

    }))

}

#[cfg_attr(not(target_family = "wasm"), tokio::test)]

#[cfg_attr(target_family = "wasm", wasm_bindgen_test::wasm_bindgen_test)]

async fn pagination_keeps_its_discovery_boundary_and_stable_ties() {

    let account = user_id!("@alice:mentions.example").to_owned();

    let ordered = vec![

        key("room", "latest"),

        key("room", "tie-z"),

        key("room", "tie-b"),

        key("room", "tie-a"),

        key("room", "oldest"),

    ];

    let mut data = Data {

        revision: 1,

        ..Data::default()

    };

    for (mention, timestamp) in [

        (ordered[0].clone(), 300),

        (ordered[1].clone(), 200),

        (ordered[2].clone(), 200),

        (ordered[3].clone(), 200),

        (ordered[4].clone(), 100),

    ] {

        data.entries

            .insert(id(&mention), entry(mention, timestamp, 1, false));

    }

    let first = data.page(&account, None, 2).unwrap();

    assert_eq!(

        first

            .entries

            .iter()

            .map(|entry| entry.key.clone())

            .collect::<Vec<_>>(),

        ordered[..2].to_vec()

    );

    let mut cursor = first.next_cursor.unwrap();

    data.revision = 2;

    let later = key("room", "discovered-later");

    data.entries.insert(id(&later), entry(later, 50, 2, false));

    let mut paged = first

        .entries

        .into_iter()

        .map(|entry| entry.key)

        .collect::<Vec<_>>();

    loop {

        let page = data.page(&account, Some(&cursor), 2).unwrap();

        paged.extend(page.entries.into_iter().map(|entry| entry.key));

        match page.next_cursor {

            Some(next) => cursor = next,

            None => break,

        }

    }

    assert_eq!(paged, ordered);

}

#[cfg_attr(not(target_family = "wasm"), tokio::test)]

#[cfg_attr(target_family = "wasm", wasm_bindgen_test::wasm_bindgen_test)]

async fn pagination_rejects_a_forged_account_and_a_future_revision() {

    let account = user_id!("@alice:mentions.example").to_owned();

    let mut data = Data {

        revision: 1,

        ..Data::default()

    };

    for event in ["one", "two"] {

        let mention = key("room", event);

        data.entries

            .insert(id(&mention), entry(mention, 10, 1, false));

    }

    let cursor = data.page(&account, None, 1).unwrap().next_cursor.unwrap();

    let mut forged_account: serde_json::Value = serde_json::from_str(&cursor).unwrap();

    forged_account["account"] = serde_json::Value::String("@mallory:mentions.example".to_owned());

    assert!(

        data.page(&account, Some(&forged_account.to_string()), 1)

            .is_err()

    );

    let mut future_revision: serde_json::Value = serde_json::from_str(&cursor).unwrap();

    future_revision["revision"] = serde_json::json!(data.revision + 1);

    assert!(

        data.page(&account, Some(&future_revision.to_string()), 1)

            .is_err()

    );

}

#[cfg_attr(not(target_family = "wasm"), tokio::test)]

#[cfg_attr(target_family = "wasm", wasm_bindgen_test::wasm_bindgen_test)]

async fn retention_discards_read_context_first_and_keeps_shared_events_until_unused() {

    let read_key = key("room", "read-mention");

    let unread_key = key("room", "unread-mention");

    let shared_key = key("room", "shared-context");

    let read_id = id(&read_key);

    let unread_id = id(&unread_key);

    let shared_id = id(&shared_key);

    let mut data = Data {

        revision: 3,

        ..Data::default()

    };

    data.entries

        .insert(read_id.clone(), entry(read_key, 10, 1, true));

    data.entries

        .insert(unread_id.clone(), entry(unread_key, 20, 2, false));

    data.events.insert(

        shared_id.clone(),

        SavedEvent {

            item: message_event("$shared-context:mentions.example", 15, "shared"),

            media: Vec::new(),

            raw: None,

        },

    );

    data.windows.insert(

        read_id.clone(),

        Window {

            before: vec![shared_id.clone()],

            target: None,

            after: Vec::new(),

            start: None,

            end: None,

        },

    );

    data.windows.insert(

        unread_id.clone(),

        Window {

            before: vec![shared_id.clone()],

            target: None,

            after: Vec::new(),

            start: None,

            end: None,

        },

    );

    assert!(data.evict_one().is_some());

    assert!(!data.windows.contains_key(&read_id));

    assert!(data.windows.contains_key(&unread_id));

    assert_eq!(

        data.entries[&read_id].capture,

        MentionCaptureState::Unavailable

    );

    assert!(!data.entries[&unread_id].read);

    assert!(data.events.contains_key(&shared_id));

    assert!(data.evict_one().is_some());

    assert!(data.windows.is_empty());

    assert!(data.entries.contains_key(&read_id));

    assert!(data.entries.contains_key(&unread_id));

    assert!(!data.events.contains_key(&shared_id));

}

#[cfg_attr(not(target_family = "wasm"), tokio::test)]

#[cfg_attr(target_family = "wasm", wasm_bindgen_test::wasm_bindgen_test)]

async fn context_uses_the_redacted_saved_event_instead_of_the_entry_preview() {

    let mention = key("room", "redacted-target");

    let mention_id = id(&mention);

    let original = message_event(

        "$redacted-target:mentions.example",

        42,

        "private original body",

    );

    let mut redacted = original.clone();

    if let TimelineItem::Event(event) = &mut redacted {

        event.content = TimelineContent::Redacted;

        event.reply_to = None;

        event.reactions.clear();

    }

    let mut data = Data::default();

    data.entries.insert(

        mention_id.clone(),

        MentionEntry {

            event: original,

            ..entry(mention.clone(), 42, 1, false)

        },

    );

    data.events.insert(

        mention_id.clone(),

        SavedEvent {

            item: redacted,

            media: Vec::new(),

            raw: None,

        },

    );

    data.windows.insert(

        mention_id,

        Window {

            before: Vec::new(),

            target: Some(id(&mention)),

            after: Vec::new(),

            start: Some("start".to_owned()),

            end: Some("end".to_owned()),

        },

    );

    let (context, media) = data.context(&mention).unwrap();

    let saved = context.context.unwrap().event.unwrap();

    let TimelineItem::Event(saved) = saved else {

        panic!("the saved target should remain a timeline event");

    };

    assert_eq!(saved.content, TimelineContent::Redacted);

    assert_eq!(

        saved.event_id.as_deref(),

        Some(event_id!("$redacted-target:mentions.example"))

    );

    assert!(media.is_empty());

}

#[cfg(any(feature = "sqlite", feature = "indexeddb"))]

mod persistence {

    use std::sync::atomic::{AtomicUsize, Ordering};

    use ruma::{events::room::MediaSource, user_id};

    use serde_json::json;

    use super::*;

    use crate::{

        MediaId, MediaKind, StoreConfig,

        mentions::store::{Account, MentionsStore, Write},

        normalise::{MediaRegistration, MediaSourceInfo},

    };

    static STORES: AtomicUsize = AtomicUsize::new(0);

    const MAX_BYTES: usize = 64 * 1024 * 1024;

    fn account() -> Account {

        Account {

            homeserver: "https://mentions.example/".to_owned(),

            user_id: user_id!("@alice:mentions.example").to_owned(),

        }

    }

    fn config() -> StoreConfig {

        let number = STORES.fetch_add(1, Ordering::Relaxed);

        #[cfg(feature = "sqlite")]

        {

            StoreConfig::sqlite(

                std::env::temp_dir().join(format!(

                    "macltok-mentions-state-{}-{number}",

                    std::process::id()

                )),

                "state test passphrase",

            )

        }

        #[cfg(feature = "indexeddb")]

        {

            StoreConfig::indexeddb(

                format!("macltok-mentions-state-{}-{number}", js_sys::Date::now()),

                "state test passphrase",

            )

        }

    }

    fn media_registration() -> MediaRegistration {

        MediaRegistration {

            id: MediaId::new("test-scope#image".to_owned()),

            kind: MediaKind::Image,

            full: MediaSourceInfo {

                source: MediaSource::Plain(

                    ruma::mxc_uri!("mxc://mentions.example/image").to_owned(),

                ),

                mimetype: Some("image/png".to_owned()),

                declared_size: Some(1234),

            },

            thumbnail: None,

        }

    }

    fn saved_data() -> Data {

        let mention = key("persisted-room", "persisted-mention");

        let mention_id = id(&mention);

        let context_item =

            message_event("$persisted-mention:mentions.example", 42, "saved message");

        let mut data = Data {

            revision: 1,

            ..Data::default()

        };

        data.entries.insert(

            mention_id.clone(),

            MentionEntry {

                event: context_item.clone(),

                ..entry(mention.clone(), 42, 1, true)

            },

        );

        data.events.insert(

            mention_id.clone(),

            SavedEvent {

                item: context_item,

                media: vec![media_registration()],

                raw: Some(

                    json!({"event_id": "$persisted-mention:mentions.example", "body": "saved raw"}),

                ),

            },

        );

        data.windows.insert(

            mention_id.clone(),

            Window {

                before: Vec::new(),

                target: Some(mention_id),

                after: Vec::new(),

                start: Some("start-token".to_owned()),

                end: Some("end-token".to_owned()),

            },

        );

        data.history_cursor = Some("history-position".to_owned());

        data

    }

    async fn open(config: &StoreConfig) -> MentionsStore {

        MentionsStore::open(config, account(), MAX_BYTES)

            .await

            .unwrap()

    }

    #[cfg_attr(not(target_family = "wasm"), tokio::test)]

    #[cfg_attr(target_family = "wasm", wasm_bindgen_test::wasm_bindgen_test)]

    async fn encrypted_store_roundtrips_inbox_context_and_read_state() {

        let config = config();

        let data = saved_data();

        let mut store = open(&config).await;

        assert_eq!(

            store

                .commit(

                    0,

                    vec![Write::Set(

                        "inbox".to_owned(),

                        serde_json::to_value(&data).unwrap(),

                    )],

                )

                .await

                .unwrap(),

            1

        );

        drop(store);

        let mut restored = open(&config).await;

        let mut restored_data: Data = restored.read("inbox").unwrap().unwrap();

        assert_eq!(restored.revision(), restored_data.revision);

        assert!(restored_data.entries.values().next().unwrap().read);

        let mention = restored_data.entries.values().next().unwrap().key.clone();

        let (context, media) = restored_data.context(&mention).unwrap();

        assert_eq!(

            context.context.unwrap().start_token.as_deref(),

            Some("start-token")

        );

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

        assert_eq!(media[0].id.as_str(), "test-scope#image");

        assert_eq!(media[0].full.mimetype.as_deref(), Some("image/png"));

        let event = restored_data.events.values().next().unwrap();

        assert_eq!(event.raw.as_ref().unwrap()["body"], "saved raw");

        restored_data.revision = 2;

        let updated_entry = restored_data.entries.values_mut().next().unwrap();

        updated_entry.read = false;

        updated_entry.revision = 2;

        restored

            .commit(

                1,

                vec![Write::Set(

                    "inbox".to_owned(),

                    serde_json::to_value(&restored_data).unwrap(),

                )],

            )

            .await

            .unwrap();

        drop(restored);

        let restored = open(&config).await;

        let restored_data: Data = restored.read("inbox").unwrap().unwrap();

        assert_eq!(restored.revision(), 2);

        assert_eq!(restored_data.revision, 2);

        assert!(!restored_data.entries.values().next().unwrap().read);

        drop(restored);

        config.delete().await.unwrap();

    }

}