macltok

use ruma::{OwnedEventId, OwnedRoomId, OwnedUserId};

#[cfg(feature = "serde")]

use serde::{Deserialize, Serialize};

use crate::{EventContext, TimelineItem};

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

pub struct MentionKey {

    pub room_id: OwnedRoomId,

    pub event_id: OwnedEventId,

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

pub enum MentionReason {

    Direct,

    Reply,

    Room,

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

pub enum MentionCaptureState {

    Pending,

    Partial,

    Ready,

    Unavailable,

    Failed { message: String, retry_at_ms: u64 },

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

pub struct MentionEntry {

    pub key: MentionKey,

    pub timestamp_ms: u64,

    pub discovered_at_ms: u64,

    pub discovery_revision: u64,

    pub revision: u64,

    pub event: TimelineItem,

    pub reasons: Vec<MentionReason>,

    pub read: bool,

    pub capture: MentionCaptureState,

    pub room_name: Option<String>,

    pub notification_suppressed: bool,

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

pub struct MentionCoverage {

    pub earliest_timestamp_ms: Option<u64>,

    pub historical_supported: Option<bool>,

    pub recovering: bool,

    pub incomplete_history: bool,

    pub gaps: Vec<MentionGap>,

    pub truncated: bool,

    pub unresolved_candidates: usize,

}

impl Default for MentionCoverage {

    fn default() -> Self {

        Self {

            earliest_timestamp_ms: None,

            historical_supported: None,

            recovering: false,

            incomplete_history: true,

            gaps: Vec::new(),

            truncated: false,

            unresolved_candidates: 0,

        }

    }

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

pub struct MentionGap {

    pub room_id: Option<OwnedRoomId>,

    pub reason: String,

    pub token: Option<String>,

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

pub struct MentionsBoundary {

    pub account: OwnedUserId,

    pub revision: u64,

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

pub struct MentionsPage {

    pub entries: Vec<MentionEntry>,

    pub next_cursor: Option<String>,

    pub end_reached: bool,

    pub coverage: MentionCoverage,

    pub unread_count: usize,

    pub revision: u64,

    pub boundary: MentionsBoundary,

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

pub struct SavedMentionContext {

    pub key: MentionKey,

    pub state: MentionCaptureState,

    pub context: Option<EventContext>,

    pub revision: u64,

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

pub struct MentionsUpdate {

    pub snapshot: MentionsPage,

    pub upserts: Vec<MentionEntry>,

    pub removed: Vec<MentionKey>,

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

pub enum MentionsCommand {

    Page { cursor: Option<String>, limit: u16 },

    Context(MentionKey),

    RetryContext(MentionKey),

    SetRead { keys: Vec<MentionKey>, read: bool },

    ReadThrough(MentionsBoundary),

    Recover,

}