macltok

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

#[cfg(feature = "serde")]

use serde::{Deserialize, Serialize};

use crate::Error;

#[derive(Clone, Debug, PartialEq)]

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

#[non_exhaustive]

pub enum HistoryRepairCommand {

    /// runs the open-time recent load again, joining one already running. the outcome

    /// arrives as `RecentHistoryChanged`

    RetryRecent { room_id: OwnedRoomId },

    FillGap {

        room_id: OwnedRoomId,

        gap_id: OwnedTransactionId,

    },

    /// stops whichever history operation the room is running

    Cancel { room_id: OwnedRoomId },

}

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

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

pub struct HistoryGap {

    pub id: OwnedTransactionId,

    pub older_boundary: Option<OwnedEventId>,

    pub newer_boundary: Option<OwnedEventId>,

    pub lifecycle: HistoryGapLifecycle,

    pub failure: Option<String>,

}

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

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

pub enum HistoryGapLifecycle {

    Idle,

    /// the last fill stopped short of joining, and another one carries on from there

    Paused {

        reason: HistoryGapPause,

    },

    Failed,

    /// accessible history ends before the older section, so this interval stays

    Unavailable,

}

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

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

pub enum HistoryGapPause {

    CursorStalled,

    Budget,

}

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

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

pub enum HistoryContinuity {

    Unresolved,

    Verified,

    AccessibleStart,

}

#[derive(Clone, Debug, PartialEq)]

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

pub enum HistoryRepairPhase {

    Bridging,

    Ready,

    Paused,

}

#[derive(Clone, Debug, PartialEq)]

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

pub enum HistoryRepairStop {

    Cancelled,

    Budget,

    HistoryUnavailable,

    CursorStalled,

}

/// one gap fill. `Bridging` when it starts, then once more when it settles

#[derive(Clone, Debug, PartialEq)]

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

pub struct HistoryRepairReport {

    pub room_id: OwnedRoomId,

    pub gap_id: OwnedTransactionId,

    pub pages: u32,

    pub events: u32,

    pub phase: HistoryRepairPhase,

    pub continuity: HistoryContinuity,

    pub stop: Option<HistoryRepairStop>,

    pub failure: Option<Error>,

}