macltok

use ruma::{OwnedEventId, OwnedRoomId};

#[cfg(feature = "serde")]

use serde::{Deserialize, Serialize};

use crate::TimelineEvent;

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

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

#[non_exhaustive]

pub enum SearchScope {

    Room(OwnedRoomId),

    /// a space's rooms, resolved by the host

    Rooms(Vec<OwnedRoomId>),

    /// every joined room

    All,

}

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

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

#[non_exhaustive]

pub enum SearchCommand {

    /// opens a search that owns the media of every hit it hands out. at most 8 stay open,

    /// opening another closes the oldest. words must all match, `"quoted phrases"` match

    /// in order and `-word` excludes, newest first

    Search {

        query: String,

        scope: SearchScope,

        limit: u16,

    },

    /// `cursor` is the previous page's `next_cursor`

    More {

        search_id: String,

        cursor: String,

        limit: u16,

    },

    /// frees the search's media. its hits' media ids stop resolving

    Close { search_id: String },

    Coverage(SearchScope),

}

/// a search's media stay resolvable until it closes, and past `EngineConfig::max_context_media`

/// its least recently used are dropped

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

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

pub struct SearchSession {

    pub search_id: String,

    pub page: SearchPage,

}

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

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

pub struct SearchPage {

    pub hits: Vec<SearchHit>,

    /// `None` once there's nothing older that matches

    pub next_cursor: Option<String>,

    pub coverage: SearchCoverage,

}

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

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

pub struct SearchHit {

    pub room_id: OwnedRoomId,

    pub event_id: OwnedEventId,

    pub timestamp_ms: u64,

    /// as event context shows it, with the latest edit applied

    pub event: TimelineEvent,

    /// utf-8 byte ranges of matched words in the content's text, the message body, a

    /// sticker's body or a poll's question

    pub matches: Vec<SearchMatch>,

}

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

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

pub struct SearchMatch {

    pub start: u32,

    pub end: u32,

}

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

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

pub struct SearchCoverage {

    pub rooms: Vec<RoomSearchCoverage>,

    /// false when the index lives in memory and starts over with the next engine

    pub persistent: bool,

    /// messages that couldn't be decrypted yet, so can't be found yet

    pub undecrypted: usize,

}

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

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

pub struct RoomSearchCoverage {

    pub room_id: OwnedRoomId,

    pub oldest_indexed_ms: Option<u64>,

    pub newest_indexed_ms: Option<u64>,

    /// backfill walked back to the oldest event the server would hand over

    pub start_reached: bool,

    pub backfill: SearchBackfill,

}

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

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

pub enum SearchBackfill {

    Waiting,

    Running,

    /// this engine's page budget for the room is spent, the next one carries on

    Paused,

    Complete,

    Disabled,

    Failed {

        message: String,

        retry_at_ms: u64,

    },

}