macltok

use std::{

    collections::HashMap,

    fmt,

    pin::Pin,

    sync::{Arc, Mutex, MutexGuard, PoisonError},

    task::{Context, Poll},

    time::Duration,

};

use futures_util::{Stream, StreamExt};

use imbl::Vector;

use matrix_sdk::{

    SendOutsideWasm,

    executor::{AbortHandle, spawn},

};

use ruma::{OwnedDeviceId, OwnedRoomId, OwnedTransactionId, OwnedUserId};

#[cfg(feature = "serde")]

use serde::{Deserialize, Serialize};

use tokio::sync::broadcast;

use crate::{

    ClientHandle, Command, ConnectionState, EncryptionState, EngineFailure, ErrorKind, Event,

    EventContextCloseReason, HistoryRepairReport, HistoryState, ImagePacks, RecentHistoryState,

    RoomSummary, ThreadListCloseReason, ThreadListEntry, TimelineCommand, TimelineDiff, TimelineId,

    TimelineItem, TypingState, UploadOutcome, VerificationState, VerificationTarget,

    engine::executor::EngineBoxFuture, transport::PublicationRegistration,

};

#[cfg(not(target_family = "wasm"))]

type EngineBoxStream<T> = futures_util::stream::BoxStream<'static, T>;

#[cfg(target_family = "wasm")]

type EngineBoxStream<T> = futures_util::stream::LocalBoxStream<'static, T>;

const DEFAULT_CAPACITY: usize = 256;

const RESYNC_BACKOFF: Duration = Duration::from_millis(100);

const RESYNC_BACKOFF_CAP: Duration = Duration::from_secs(10);

/// everything the engine has said so far, folded together

#[derive(Clone, Debug, PartialEq)]

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

#[non_exhaustive]

pub struct State {

    pub user_id: Option<OwnedUserId>,

    pub session: SessionStatus,

    pub connection: ConnectionState,

    pub encryption: Option<EncryptionState>,

    pub verification: Option<VerificationState>,

    pub verification_target: Option<VerificationTarget>,

    pub mentions: Option<crate::MentionsPage>,

    pub rooms: Vector<RoomSummary>,

    pub image_packs: ImagePacks,

    pub timelines: imbl::HashMap<TimelineId, TimelineState>,

    pub thread_lists: imbl::HashMap<OwnedRoomId, ThreadListState>,

    /// a room without an entry is idle. closing a room drops its entries here and in `repairs`

    pub recent_history: imbl::HashMap<OwnedRoomId, RecentHistoryState>,

    pub repairs: imbl::HashMap<OwnedRoomId, HistoryRepairReport>,

    pub typing: imbl::HashMap<OwnedRoomId, Vec<OwnedUserId>>,

    pub uploads: imbl::HashMap<OwnedTransactionId, UploadState>,

    /// what stopped the engine, if something went wrong

    pub engine_failure: Option<EngineFailure>,

    /// the last save of the session record that failed, until one succeeds

    pub session_save_failure: Option<String>,

}

#[derive(Clone, Debug, PartialEq)]

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

#[non_exhaustive]

pub struct TimelineState {

    pub items: Vector<TimelineItem>,

    pub history: HistoryState,

    /// a batch didn't fit, so `items` is the last good copy until the next reset

    pub diverged: bool,

}

#[derive(Clone, Debug, PartialEq)]

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

#[non_exhaustive]

pub struct ThreadListState {

    pub entries: Vector<ThreadListEntry>,

    pub history: HistoryState,

}

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

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

#[non_exhaustive]

pub struct UploadState {

    pub room_id: OwnedRoomId,

    pub uploaded_bytes: u64,

    pub total_bytes: u64,

    pub complete: bool,

    pub failure: Option<UploadFailure>,

}

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

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

#[non_exhaustive]

pub struct UploadFailure {

    pub kind: ErrorKind,

    pub will_retry: bool,

}

/// the `Termination` it'll end in, as far as the events tell

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

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

pub enum SessionStatus {

    Active,

    SoftLoggedOut {

        device_id: OwnedDeviceId,

    },

    AccessRevoked,

    LoggedOut,

    /// stopped with the session still good

    Stopped,

}

#[derive(Clone, Debug)]

#[non_exhaustive]

pub struct Update {

    /// one more than the update before it, and a `State` carries the one it's current as of

    pub sequence: u64,

    pub change: StateChange,

}

#[derive(Clone, Debug)]

pub enum StateChange {

    /// start over from this. a subscription opens with one and gets another after lagging

    State(Arc<State>),

    Authenticated(OwnedUserId),

    Session(SessionStatus),

    /// the record on disk may now hold a spent refresh token

    SessionSaveFailed(String),

    /// saved again after `SessionSaveFailed`

    SessionSaved,

    Connection(ConnectionState),

    Encryption(EncryptionState),

    Verification(VerificationState),

    VerificationTarget(VerificationTarget),

    Mentions(crate::MentionsUpdate),

    /// room modes arrive with the `Rooms` that follows

    NotificationSettings,

    Rooms(Vector<RoomSummary>),

    ImagePacks(ImagePacks),

    Timeline {

        timeline_id: TimelineId,

        change: TimelineChange,

    },

    History {

        timeline_id: TimelineId,

        state: HistoryState,

    },

    ThreadList {

        room_id: OwnedRoomId,

        change: ThreadListChange,

    },

    RecentHistory {

        room_id: OwnedRoomId,

        state: RecentHistoryState,

    },

    HistoryRepair(HistoryRepairReport),

    Typing(TypingState),

    EventContextClosed {

        context_id: String,

        reason: EventContextCloseReason,

    },

    SearchClosed {

        search_id: String,

        reason: crate::SearchCloseReason,

    },

    Upload {

        transaction_id: OwnedTransactionId,

        upload: UploadState,

    },

    UploadFinished {

        room_id: OwnedRoomId,

        transaction_id: OwnedTransactionId,

        outcome: UploadOutcome,

    },

    Failed(EngineFailure),

}

#[derive(Clone, Debug)]

pub enum TimelineChange {

    Reset {

        items: Vector<TimelineItem>,

    },

    /// `items` is what applying `diffs` left

    Changed {

        diffs: Arc<[TimelineDiff]>,

        items: Vector<TimelineItem>,

    },

    /// a batch didn't fit. a resync is on its way and nothing changes until its reset

    Diverged,

    Closed,

}

#[derive(Clone, Debug)]

pub enum ThreadListChange {

    Reset {

        entries: Vector<ThreadListEntry>,

    },

    /// `entries` is what applying `upserts` left

    Changed {

        upserts: Arc<[ThreadListEntry]>,

        entries: Vector<ThreadListEntry>,

    },

    History(HistoryState),

    Closed(ThreadListCloseReason),

}

/// drains the event stream into a `State` that any number of `MirrorHandle`s watch

pub struct Mirror {

    handle: ClientHandle,

    events: EngineBoxStream<Event>,

    shared: Arc<Shared>,

    _publication: PublicationRegistration,

    resyncs: HashMap<TimelineId, AbortHandle>,

    rooms_fetch: Option<AbortHandle>,

    packs_fetch: Option<AbortHandle>,

}

impl fmt::Debug for Mirror {

    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

        formatter.debug_struct("Mirror").finish_non_exhaustive()

    }

}

impl Mirror {

    /// takes any stream of the engine's events, so a host can still look at them on the way past

    pub fn new(

        handle: ClientHandle,

        events: impl Stream<Item = Event> + SendOutsideWasm + 'static,

    ) -> (Self, MirrorHandle) {

        Self::with_capacity(handle, events, DEFAULT_CAPACITY)

    }

    /// `capacity` updates can queue for a subscriber before it lags and starts over. a zero

    /// capacity counts as one

    pub fn with_capacity(

        handle: ClientHandle,

        events: impl Stream<Item = Event> + SendOutsideWasm + 'static,

        capacity: usize,

    ) -> (Self, MirrorHandle) {

        let state = State {

            user_id: None,

            session: SessionStatus::Active,

            connection: *handle.connection_state().borrow(),

            encryption: handle.encryption_state(),

            verification: None,

            verification_target: None,

            mentions: None,

            rooms: Vector::new(),

            image_packs: ImagePacks::default(),

            timelines: imbl::HashMap::new(),

            thread_lists: imbl::HashMap::new(),

            recent_history: imbl::HashMap::new(),

            repairs: imbl::HashMap::new(),

            typing: imbl::HashMap::new(),

            uploads: imbl::HashMap::new(),

            engine_failure: None,

            session_save_failure: None,

        };

        let shared = Arc::new(Shared {

            published: Mutex::new(Published {

                state: Arc::new(state),

                sequence: 0,

                updates: Some(broadcast::channel(capacity.max(1)).0),

                rooms_fetch: Fetch::Idle,

                packs_fetch: Fetch::Idle,

            }),

        });

        let publication = handle.register_publication_mirror();

        #[cfg(not(target_family = "wasm"))]

        let events = events.boxed();

        #[cfg(target_family = "wasm")]

        let events = events.boxed_local();

        let mirror = Self {

            handle,

            events,

            shared: shared.clone(),

            _publication: publication,

            resyncs: HashMap::new(),

            rooms_fetch: None,

            packs_fetch: None,

        };

        (mirror, MirrorHandle { shared })

    }

    /// resolves once the event stream ends, which is just after `Stopped`

    pub fn run(mut self) -> EngineBoxFuture<'static, ()> {

        Box::pin(async move {

            self.refetch_rooms();

            self.refetch_image_packs();

            while let Some(event) = self.events.next().await {

                self.apply(event);

            }

        })

    }

    fn apply(&mut self, event: Event) {

        match event {

            Event::ConnectionChanged(connection) => self.publish(|state| {

                state.connection = connection;

                Some(StateChange::Connection(connection))

            }),

            Event::Authenticated { user_id } => self.publish(|state| {

                state.user_id = Some(user_id.clone());

                Some(StateChange::Authenticated(user_id))

            }),

            Event::SessionSaveFailed { message } => self.publish(|state| {

                state.session_save_failure = Some(message.clone());

                Some(StateChange::SessionSaveFailed(message))

            }),

            Event::SessionTokensChanged => self.publish(|state| {

                state.session_save_failure.take()?;

                Some(StateChange::SessionSaved)

            }),

            Event::SessionAccessRejected { soft_logout } => self.publish(|state| {

                state.mentions = None;

                state.session = match soft_logout {

                    Some(device_id) => SessionStatus::SoftLoggedOut { device_id },

                    None => SessionStatus::AccessRevoked,

                };

                Some(StateChange::Session(state.session.clone()))

            }),

            Event::LoggedOut => self.publish(|state| {

                state.mentions = None;

                state.session = SessionStatus::LoggedOut;

                Some(StateChange::Session(SessionStatus::LoggedOut))

            }),

            Event::Stopped => {

                self.cancel_resyncs();

                self.publish(|state| {

                    if state.session != SessionStatus::Active {

                        return None;

                    }

                    state.session = SessionStatus::Stopped;

                    Some(StateChange::Session(SessionStatus::Stopped))

                });

            }

            Event::Failed(failure) => self.publish(|state| {

                state.engine_failure = Some(failure.clone());

                Some(StateChange::Failed(failure))

            }),

            Event::NotificationSettingsChanged => {

                self.publish(|_| Some(StateChange::NotificationSettings));

            }

            Event::RoomsChanged => self.refetch_rooms(),

            Event::MentionsChanged(update) => self.publish(|state| {

                if state.session != SessionStatus::Active

                    || state

                        .user_id

                        .as_ref()

                        .is_some_and(|account| account != &update.snapshot.boundary.account)

                {

                    return None;

                }

                if state

                    .mentions

                    .as_ref()

                    .map_or(false, |current| update.snapshot.revision < current.revision)

                {

                    return None;

                }

                state.mentions = Some(update.snapshot.clone());

                Some(StateChange::Mentions(update))

            }),

            Event::ImagePacksChanged => self.refetch_image_packs(),

            Event::EncryptionChanged(encryption) => self.publish(|state| {

                state.encryption = Some(encryption.clone());

                Some(StateChange::Encryption(encryption))

            }),

            Event::VerificationChanged(verification) => self.publish(|state| {

                state.verification = Some(verification.clone());

                Some(StateChange::Verification(verification))

            }),

            Event::VerificationTargetChanged(target) => self.publish(|state| {

                state.verification_target = Some(target.clone());

                Some(StateChange::VerificationTarget(target))

            }),

            Event::TimelineReset { timeline_id, items } => {

                self.cancel_resync(&timeline_id);

                self.publish(|state| {

                    let history = state

                        .timelines

                        .get(&timeline_id)

                        .map_or(HistoryState::Idle, |timeline| timeline.history.clone());

                    let timeline = TimelineState {

                        items: items.clone(),

                        history,

                        diverged: false,

                    };

                    state.timelines.insert(timeline_id.clone(), timeline);

                    Some(StateChange::Timeline {

                        timeline_id,

                        change: TimelineChange::Reset { items },

                    })

                });

            }

            Event::TimelineChanged { timeline_id, diffs } => self.apply_diffs(timeline_id, diffs),

            Event::HistoryChanged {

                timeline_id,

                state: history,

            } => self.publish(|state| {

                state.timelines.get_mut(&timeline_id)?.history = history.clone();

                Some(StateChange::History {

                    timeline_id,

                    state: history,

                })

            }),

            Event::RecentHistoryChanged {

                room_id,

                state: recent,

            } => self.publish(|state| {

                if recent == RecentHistoryState::Idle {

                    state.recent_history.remove(&room_id);

                } else {

                    state.recent_history.insert(room_id.clone(), recent.clone());

                }

                Some(StateChange::RecentHistory {

                    room_id,

                    state: recent,

                })

            }),

            Event::HistoryRepairChanged(report) => self.publish(|state| {

                state.repairs.insert(report.room_id.clone(), report.clone());

                Some(StateChange::HistoryRepair(report))

            }),

            Event::PublicationBarrier { acknowledgement } => {

                if let Some(acknowledgement) = acknowledgement {

                    acknowledgement.complete(true);

                }

            }

            Event::TimelineClosed { timeline_id } => {

                self.cancel_resync(&timeline_id);

                self.publish(|state| {

                    state.timelines.remove(&timeline_id)?;

                    if let TimelineId::Room(room_id) = &timeline_id {

                        state.repairs.remove(room_id);

                    }

                    Some(StateChange::Timeline {

                        timeline_id,

                        change: TimelineChange::Closed,

                    })

                });

            }

            Event::EventContextClosed { context_id, reason } => {

                self.publish(|_| Some(StateChange::EventContextClosed { context_id, reason }));

            }

            Event::SearchClosed { search_id, reason } => {

                self.publish(|_| Some(StateChange::SearchClosed { search_id, reason }));

            }

            Event::ThreadListReset { room_id, entries } => self.publish(|state| {

                let history = state

                    .thread_lists

                    .get(&room_id)

                    .map_or(HistoryState::Idle, |list| list.history.clone());

                state.thread_lists.insert(

                    room_id.clone(),

                    ThreadListState {

                        entries: entries.clone(),

                        history,

                    },

                );

                Some(StateChange::ThreadList {

                    room_id,

                    change: ThreadListChange::Reset { entries },

                })

            }),

            Event::ThreadListChanged { room_id, upserts } => self.publish(|state| {

                let list = state.thread_lists.get_mut(&room_id)?;

                for entry in &upserts {

                    ThreadListEntry::upsert(&mut list.entries, entry.clone());

                }

                Some(StateChange::ThreadList {

                    room_id,

                    change: ThreadListChange::Changed {

                        upserts: upserts.into(),

                        entries: list.entries.clone(),

                    },

                })

            }),