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,

    /// a highlighting push rule matched with no structured mention or reply, such as a

    /// notification keyword

    Keyword,

}

#[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, Default, 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 gaps: Vec<MentionGap>,

    pub truncated: bool,

    pub unresolved_candidates: usize,

}

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

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

pub struct MentionGap {

    pub room_id: Option<OwnedRoomId>,

    pub reason: MentionGapReason,

    pub token: Option<String>,

}

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

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

pub enum MentionGapReason {

    SyncDiscontinuity,

    /// an already observed room came back limited, `token` is its `prev_batch`

    LimitedTimeline,

    RoomLeft,

    ContextUnavailable,

    NotificationHistoryUnavailable,

    /// a candidate stayed undecryptable or unresolved for a week and was dropped

    CandidateExpired,

    StoreReset,

    /// a write failed, the inbox carries on in memory and a restart loses the unwritten part

    StoreFailed,

    HookTimedOut,

}

#[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))]

#[non_exhaustive]

pub enum MentionsCommand {

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

    Context(MentionKey),

    RetryContext(MentionKey),

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

    ReadThrough(MentionsBoundary),

    Recover,

}