macltok

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

#[cfg(feature = "serde")]

use serde::{Deserialize, Serialize};

use crate::Error;

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

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

pub enum HistoryRepairPolicy {

    StartRecent,

    Bridge,

    BridgeShortGaps { threshold_ms: u64 },

}

impl Default for HistoryRepairPolicy {

    fn default() -> Self {

        Self::StartRecent

    }

}

#[derive(Clone, Debug, PartialEq)]

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

pub struct HistoryRepairBudget {

    pub max_pages: u16,

    pub max_events: u32,

    pub max_duration_ms: u64,

}

impl Default for HistoryRepairBudget {

    fn default() -> Self {

        Self {

            max_pages: 4,

            max_events: 200,

            max_duration_ms: 15_000,

        }

    }

}

#[derive(Clone, Debug, PartialEq)]

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

pub enum HistoryRepairCommand {

    Start {

        room_id: OwnedRoomId,

        policy: Option<HistoryRepairPolicy>,

        budget: HistoryRepairBudget,

    },

    Continue {

        room_id: OwnedRoomId,

        budget: HistoryRepairBudget,

    },

    Cancel {

        room_id: OwnedRoomId,

    },

    StartRecent {

        room_id: OwnedRoomId,

    },

    FillGap {

        room_id: OwnedRoomId,

        gap_id: OwnedTransactionId,

    },

    GetPolicy,

    SetPolicy(HistoryRepairPolicy),

}

#[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 continuity: HistoryContinuity,

    pub failure: Option<String>,

}

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

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

pub enum HistoryGapLifecycle {

    Idle,

    Fetching,

    Paused,

    Failed,

    Unavailable,

}

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

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

pub enum HistoryRepairStrategy {

    Recent,

    Overlap,

    Bridge,

}

#[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 {

    FetchingRecent,

    Bridging,

    Ready,

    Paused,

}

#[derive(Clone, Debug, PartialEq)]

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

pub enum HistoryRepairStop {

    Cancelled,

    Budget,

    HistoryUnavailable,

    NoAnchor,

    CursorStalled,

}

#[derive(Clone, Debug, PartialEq)]

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

pub struct HistoryRepairReport {

    pub room_id: OwnedRoomId,

    #[cfg_attr(feature = "serde", serde(default))]

    pub gap_id: Option<OwnedTransactionId>,

    pub requested_policy: HistoryRepairPolicy,

    pub strategy: HistoryRepairStrategy,

    pub coverage_duration_ms: Option<u64>,

    pub threshold_evaluated: bool,

    pub pages: u32,

    pub events: u32,

    pub phase: HistoryRepairPhase,

    pub continuity: HistoryContinuity,

    pub recent_available: bool,

    pub stop: Option<HistoryRepairStop>,

    pub failure: Option<Error>,

}

#[cfg(all(test, feature = "serde"))]

mod tests {

    use super::*;

    use crate::ErrorKind;

    use ruma::room_id;

    #[test]

    fn history_repair_types_round_trip_through_serde() {

        let command = HistoryRepairCommand::Start {

            room_id: room_id!("!room:example.org").to_owned(),

            policy: Some(HistoryRepairPolicy::BridgeShortGaps {

                threshold_ms: 86_400_000,

            }),

            budget: HistoryRepairBudget::default(),

        };

        let encoded_command = serde_json::to_value(&command).unwrap();

        let decoded_command: HistoryRepairCommand =

            serde_json::from_value(encoded_command).unwrap();

        assert_eq!(decoded_command, command);

        let report = HistoryRepairReport {

            gap_id: None,

            room_id: room_id!("!room:example.org").to_owned(),

            requested_policy: HistoryRepairPolicy::Bridge,

            strategy: HistoryRepairStrategy::Overlap,

            coverage_duration_ms: Some(86_400_000),

            threshold_evaluated: false,

            pages: 3,

            events: 42,

            phase: HistoryRepairPhase::Paused,

            continuity: HistoryContinuity::Unresolved,

            recent_available: true,

            stop: Some(HistoryRepairStop::Budget),

            failure: Some(Error::new(ErrorKind::Timeline, "repair failed")),

        };

        let encoded_report = serde_json::to_value(&report).unwrap();

        let decoded_report: HistoryRepairReport = serde_json::from_value(encoded_report).unwrap();

        assert_eq!(decoded_report, report);

    }

}