macltok

public
Star0
Watch0
10 commits 3 branches 0 tags 0 releases3.0 MiB
use std::{fmt, sync::Arc};

use imbl::Vector;
use ruma::{
    OwnedDeviceId, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId, OwnedRoomOrAliasId,
    OwnedServerName, OwnedTransactionId, OwnedUserId,
    events::{
        AnyGlobalAccountDataEventContent, AnyRoomAccountDataEventContent, AnySyncTimelineEvent,
        GlobalAccountDataEventType, RoomAccountDataEventType,
        room::member::StrippedRoomMemberEvent,
    },
    serde::Raw,
};
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

/// every command answers exactly once through `ClientHandle::send` or `execute`.
/// the event stream only ever carries state
#[derive(Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum Command {
    Account(AccountCommand),
    Room(RoomCommand),
    Timeline(TimelineCommand),
    Media(MediaCommand),
    Encryption(EncryptionCommand),
    Notification(NotificationCommand),
    Lifecycle(LifecycleCommand),
}

#[derive(Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum AccountCommand {
    Logout,
    SetAccountData {
        event_type: GlobalAccountDataEventType,
        content: Raw<AnyGlobalAccountDataEventContent>,
    },
    SetDisplayName(Option<String>),
    SetAvatar(Option<OwnedMxcUri>),
    /// uploads the image and points the profile at it, same byte cap as any upload
    UploadAvatar {
        mimetype: String,
        bytes: Vec<u8>,
    },
    RenameDevice {
        device_id: OwnedDeviceId,
        display_name: String,
    },
    DeleteDevices {
        device_ids: Vec<OwnedDeviceId>,
        auth: Option<crate::InteractiveAuth>,
    },
}

#[derive(Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum RoomCommand {
    /// the snapshot turns up as `Event::TimelineReset`. opening an open room sends a fresh one
    Open(OwnedRoomId),
    Close(OwnedRoomId),
    Join {
        room: OwnedRoomOrAliasId,
        via: Vec<OwnedServerName>,
    },
    Leave(OwnedRoomId),
    Forget(OwnedRoomId),
    AcceptInvite(OwnedRoomId),
    RejectInvite(OwnedRoomId),
    InviteUser {
        room_id: OwnedRoomId,
        user_id: OwnedUserId,
    },
    KickUser {
        room_id: OwnedRoomId,
        user_id: OwnedUserId,
        reason: Option<String>,
    },
    BanUser {
        room_id: OwnedRoomId,
        user_id: OwnedUserId,
        reason: Option<String>,
    },
    UnbanUser {
        room_id: OwnedRoomId,
        user_id: OwnedUserId,
        reason: Option<String>,
    },
    SetPowerLevels {
        room_id: OwnedRoomId,
        changes: PowerLevelChanges,
    },
    SetUserPowerLevel {
        room_id: OwnedRoomId,
        user_id: OwnedUserId,
        level: i64,
    },
    Create(CreateRoomOptions),
    /// hands back the existing dm if there is one
    CreateDirect(OwnedUserId),
    CancelSend {
        room_id: OwnedRoomId,
        transaction_id: OwnedTransactionId,
    },
    RetrySend {
        room_id: OwnedRoomId,
        transaction_id: OwnedTransactionId,
    },
    SetTyping {
        room_id: OwnedRoomId,
        typing: bool,
    },
    SetAccountData {
        room_id: OwnedRoomId,
        event_type: RoomAccountDataEventType,
        content: Raw<AnyRoomAccountDataEventContent>,
    },
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct CreateRoomOptions {
    pub name: Option<String>,
    pub topic: Option<String>,
    pub alias_localpart: Option<String>,
    pub invite: Vec<OwnedUserId>,
    pub direct: bool,
    pub visibility: RoomVisibility,
    pub preset: Option<RoomPreset>,
}

impl CreateRoomOptions {
    #[must_use]
    pub fn with_name(mut self, name: impl Into<String>) -> Self {
        self.name = Some(name.into());
        self
    }

    #[must_use]
    pub fn with_topic(mut self, topic: impl Into<String>) -> Self {
        self.topic = Some(topic.into());
        self
    }

    #[must_use]
    pub fn with_alias_localpart(mut self, localpart: impl Into<String>) -> Self {
        self.alias_localpart = Some(localpart.into());
        self
    }

    #[must_use]
    pub fn with_invite(mut self, invite: impl IntoIterator<Item = OwnedUserId>) -> Self {
        self.invite = invite.into_iter().collect();
        self
    }

    #[must_use]
    pub const fn with_direct(mut self, direct: bool) -> Self {
        self.direct = direct;
        self
    }

    #[must_use]
    pub const fn with_visibility(mut self, visibility: RoomVisibility) -> Self {
        self.visibility = visibility;
        self
    }

    #[must_use]
    pub const fn with_preset(mut self, preset: RoomPreset) -> Self {
        self.preset = Some(preset);
        self
    }
}

#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum RoomVisibility {
    #[default]
    Private,
    Public,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum RoomPreset {
    PrivateChat,
    TrustedPrivateChat,
    PublicChat,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum TimelineCommand {
    OpenThread {
        room_id: OwnedRoomId,
        root_event_id: OwnedEventId,
    },
    CloseThread {
        room_id: OwnedRoomId,
        root_event_id: OwnedEventId,
    },
    /// Re-emit an authoritative reset for an open room or thread without
    /// closing it. The reset arrives before this command's terminal result.
    Resync {
        timeline_id: TimelineId,
    },
    Paginate {
        timeline_id: TimelineId,
        limit: u16,
    },
    Send {
        timeline_id: TimelineId,
        content: MessageContent,
    },
    Edit {
        timeline_id: TimelineId,
        target: EventRef,
        content: MessageEditContent,
    },
    /// redacting your own unsent message just cancels it
    Redact {
        timeline_id: TimelineId,
        target: EventRef,
        reason: Option<String>,
    },
    ToggleReaction {
        timeline_id: TimelineId,
        target: EventRef,
        key: String,
    },
    /// works on a closed room too, it just can't refuse to move the marker backwards
    MarkRead {
        timeline_id: TimelineId,
        event_id: OwnedEventId,
    },
}

impl TimelineCommand {
    #[must_use]
    pub const fn room_id(&self) -> &OwnedRoomId {
        match self {
            Self::OpenThread { room_id, .. } | Self::CloseThread { room_id, .. } => room_id,
            Self::Resync { timeline_id }
            | Self::Paginate { timeline_id, .. }
            | Self::Send { timeline_id, .. }
            | Self::Edit { timeline_id, .. }
            | Self::Redact { timeline_id, .. }
            | Self::ToggleReaction { timeline_id, .. }
            | Self::MarkRead { timeline_id, .. } => timeline_id.room_id(),
        }
    }

    #[must_use]
    pub const fn timeline_id(&self) -> Option<&TimelineId> {
        match self {
            Self::OpenThread { .. } | Self::CloseThread { .. } => None,
            Self::Resync { timeline_id }
            | Self::Paginate { timeline_id, .. }
            | Self::Send { timeline_id, .. }
            | Self::Edit { timeline_id, .. }
            | Self::Redact { timeline_id, .. }
            | Self::ToggleReaction { timeline_id, .. }
            | Self::MarkRead { timeline_id, .. } => Some(timeline_id),
        }
    }
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum TimelineId {
    Room(OwnedRoomId),
    Thread {
        room_id: OwnedRoomId,
        root_event_id: OwnedEventId,
    },
}

impl TimelineId {
    #[must_use]
    pub const fn room_id(&self) -> &OwnedRoomId {
        match self {
            Self::Room(room_id) | Self::Thread { room_id, .. } => room_id,
        }
    }

    #[must_use]
    pub fn thread(room_id: OwnedRoomId, root_event_id: OwnedEventId) -> Self {
        Self::Thread {
            room_id,
            root_event_id,
        }
    }

    #[must_use]
    pub fn thread_root(&self) -> Option<&OwnedEventId> {
        match self {
            Self::Room(_) => None,
            Self::Thread { root_event_id, .. } => Some(root_event_id),
        }
    }
}

impl From<OwnedRoomId> for TimelineId {
    fn from(room_id: OwnedRoomId) -> Self {
        Self::Room(room_id)
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum MediaCommand {
    /// succeeds once the send queue has it. progress and failure arrive as events
    Upload(AttachmentUpload),
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct AttachmentUpload {
    pub timeline_id: TimelineId,
    pub filename: String,
    pub mimetype: String,
    pub bytes: Vec<u8>,
    pub caption: Option<String>,
    pub details: Option<UploadDetails>,
    pub thumbnail: Option<UploadThumbnail>,
}

impl AttachmentUpload {
    #[must_use]
    pub fn new(
        timeline_id: impl Into<TimelineId>,
        filename: impl Into<String>,
        mimetype: impl Into<String>,
        bytes: Vec<u8>,
    ) -> Self {
        Self {
            timeline_id: timeline_id.into(),
            filename: filename.into(),
            mimetype: mimetype.into(),
            bytes,
            caption: None,
            details: None,
            thumbnail: None,
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum UploadDetails {
    Image {
        width: Option<u32>,
        height: Option<u32>,
        blurhash: Option<String>,
    },
    Video {
        width: Option<u32>,
        height: Option<u32>,
        duration_ms: Option<u64>,
        blurhash: Option<String>,
    },
    Audio {
        duration_ms: Option<u64>,
    },
    Voice {
        duration_ms: u64,
        waveform: Vec<u16>,
    },
    File,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct UploadThumbnail {
    pub bytes: Vec<u8>,
    pub mimetype: String,
    pub width: u32,
    pub height: u32,
}

impl UploadThumbnail {
    #[must_use]
    pub fn new(bytes: Vec<u8>, mimetype: impl Into<String>, width: u32, height: u32) -> Self {
        Self {
            bytes,
            mimetype: mimetype.into(),
            width,
            height,
        }
    }
}

#[derive(Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum EncryptionCommand {
    Recover(String),
    CreateKeyBackup,
    EnableKeyBackup,
    DisableKeyBackup { delete_from_server: bool },
    RecoverKeyBackup(String),
    StartVerification(VerificationTarget),
    Verify(VerificationAction),
}

impl fmt::Debug for EncryptionCommand {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Recover(_) => formatter.debug_tuple("Recover").field(&"...").finish(),
            Self::CreateKeyBackup => formatter.write_str("CreateKeyBackup"),
            Self::EnableKeyBackup => formatter.write_str("EnableKeyBackup"),
            Self::DisableKeyBackup { delete_from_server } => formatter
                .debug_struct("DisableKeyBackup")
                .field("delete_from_server", delete_from_server)
                .finish(),
            Self::RecoverKeyBackup(_) => formatter
                .debug_tuple("RecoverKeyBackup")
                .field(&"...")
                .finish(),
            Self::StartVerification(target) => formatter
                .debug_tuple("StartVerification")
                .field(target)
                .finish(),
            Self::Verify(action) => formatter.debug_tuple("Verify").field(action).finish(),
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum NotificationCommand {
    SetRoomMode {
        room_id: OwnedRoomId,
        mode: RoomNotificationMode,
    },
    ResetRoomMode(OwnedRoomId),
    SetDefaultMode {
        encrypted: bool,
        one_to_one: bool,
        mode: RoomNotificationMode,
    },
    AddKeyword(String),
    RemoveKeyword(String),
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum LifecycleCommand {
    Shutdown,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum CommandOutput {
    Done,
    Room(OwnedRoomId),
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum MessageContent {
    Text {
        content: RichText,
        mentions: MessageMentions,
    },
    Emote {
        content: RichText,
        mentions: MessageMentions,
    },
    Reply {
        event_id: OwnedEventId,
        content: RichText,
        mentions: MessageMentions,
        notify_replied_to: bool,
    },
}

impl MessageContent {
    #[must_use]
    pub fn text(body: impl Into<String>) -> Self {
        Self::Text {
            content: RichText::plain(body),
            mentions: MessageMentions::default(),
        }
    }

    #[must_use]
    pub fn html(body: impl Into<String>, formatted_body: impl Into<String>) -> Self {
        Self::Text {
            content: RichText::html(body, formatted_body),
            mentions: MessageMentions::default(),
        }
    }

    #[must_use]
    pub fn emote(content: RichText, mentions: MessageMentions) -> Self {
        Self::Emote { content, mentions }
    }

    #[must_use]
    pub fn reply(event_id: OwnedEventId, content: RichText, mentions: MessageMentions) -> Self {
        Self::Reply {
            event_id,
            content,
            mentions,
            notify_replied_to: true,
        }
    }

    #[must_use]
    pub fn reply_without_notification(
        event_id: OwnedEventId,
        content: RichText,
        mentions: MessageMentions,
    ) -> Self {
        Self::Reply {
            event_id,
            content,
            mentions,
            notify_replied_to: false,
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum MessageEditContent {
    Text {
        content: RichText,
        mentions: MessageMentions,
    },
    Emote {
        content: RichText,
        mentions: MessageMentions,
    },
}

impl MessageEditContent {
    #[must_use]
    pub fn text(body: impl Into<String>) -> Self {
        Self::Text {
            content: RichText::plain(body),
            mentions: MessageMentions::default(),
        }
    }

    #[must_use]
    pub fn html(body: impl Into<String>, formatted_body: impl Into<String>) -> Self {
        Self::Text {
            content: RichText::html(body, formatted_body),
            mentions: MessageMentions::default(),
        }
    }

    #[must_use]
    pub fn emote(content: RichText, mentions: MessageMentions) -> Self {
        Self::Emote { content, mentions }
    }
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct RichText {
    pub body: String,
    pub formatted_body: Option<String>,
}

impl RichText {
    #[must_use]
    pub fn plain(body: impl Into<String>) -> Self {
        Self {
            body: body.into(),
            formatted_body: None,
        }
    }

    #[must_use]
    pub fn html(body: impl Into<String>, formatted_body: impl Into<String>) -> Self {
        Self {
            body: body.into(),
            formatted_body: Some(formatted_body.into()),
        }
    }
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct MessageMentions {
    pub user_ids: Vec<OwnedUserId>,
    pub room: bool,
}

impl MessageMentions {
    #[must_use]
    pub fn with_user_ids(user_ids: impl IntoIterator<Item = OwnedUserId>) -> Self {
        Self {
            user_ids: user_ids.into_iter().collect(),
            room: false,
        }
    }

    #[must_use]
    pub fn room() -> Self {
        Self {
            user_ids: Vec::new(),
            room: true,
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum Event {
    ConnectionChanged(ConnectionState),
    Authenticated {
        user_id: OwnedUserId,
    },
    /// Refresh tokens changed. Persist a fresh `ClientHandle::session_record()`
    /// atomically; a record captured before this event may no longer restore.
    SessionTokensChanged,
    /// the server stopped honouring our token and the engine stops. on a soft
    /// logout keep the store and log in again with the same device, otherwise
    /// the record and the store are both dead
    SessionAccessRejected {
        soft_logout: bool,
    },
    NotificationSettingsChanged,
    VerificationTargetChanged(VerificationTarget),
    RoomsChanged,
    /// replaces whatever you had for this timeline. every diff after it applies to it
    TimelineReset {
        timeline_id: TimelineId,
        items: Vector<TimelineItem>,
    },
    TimelineChanged {
        timeline_id: TimelineId,
        diffs: Vec<TimelineDiff>,
    },
    HistoryChanged {
        timeline_id: TimelineId,
        state: HistoryState,
    },
    /// the timeline was closed, or its room was left, and nothing more comes for it
    /// until another `TimelineReset`
    TimelineClosed {
        timeline_id: TimelineId,
    },
    /// a room that stops being watched says so with an empty `users`
    TypingChanged(TypingState),
    MediaUploadProgress {
        room_id: OwnedRoomId,
        transaction_id: OwnedTransactionId,
        uploaded_bytes: u64,
        total_bytes: u64,
        complete: bool,
    },
    /// not the end of it. `will_retry` means the send queue has another go by itself,
    /// otherwise it waits for `retry_send` or `cancel_send`
    MediaUploadFailed {
        room_id: OwnedRoomId,
        transaction_id: OwnedTransactionId,
        kind: crate::ErrorKind,
        will_retry: bool,
    },
    /// every upload ends with exactly one of these
    MediaUploadFinished {
        room_id: OwnedRoomId,
        transaction_id: OwnedTransactionId,
        outcome: UploadOutcome,
    },
    EncryptionChanged(EncryptionState),
    VerificationChanged(VerificationState),
    /// logout went through and the engine stops. delete the record and the store
    LoggedOut,
    Failed(EngineFailure),
    /// always the last event. keep the saved record unless `LoggedOut` or a
    /// hard `SessionAccessRejected` came first. commands still in flight answer `Interrupted`
    Stopped,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum UploadOutcome {
    Sent {
        event_id: OwnedEventId,
    },
    Cancelled,
    /// its room was forgotten, and the queue with it
    RoomForgotten,
    /// the sdk's update channel overflowed while it ended, so whether it was sent is unknown
    Missed,
}

/// why `Engine::run` came back, when nothing went wrong
#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum Termination {
    ShutDown,
    /// every `ClientHandle` was dropped, so nobody could have asked for anything else
    HandlesDropped,
    LoggedOut,
    /// the server rejected our token for good
    AccessRevoked,
    /// the server wants this device to log in again, and its e2ee keys live in the store
    SoftLoggedOut {
        device_id: OwnedDeviceId,
    },
}

impl Termination {
    #[must_use]
    pub const fn retain(&self) -> Retain {
        match self {
            Self::ShutDown | Self::HandlesDropped => Retain::RecordAndStore,
            Self::SoftLoggedOut { .. } => Retain::Store,
            Self::LoggedOut | Self::AccessRevoked => Retain::Nothing,
        }
    }
}

/// what's still worth keeping of the saved record and the store
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum Retain {
    RecordAndStore,
    Store,
    Nothing,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum ConnectionState {
    Idle,
    Connecting,
    Online,
    Offline,
    Stopped,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct RoomSummary {
    pub room_id: OwnedRoomId,
    pub name: String,
    pub membership: RoomMembership,
    pub unread_messages: u64,
    pub unread_mentions: u64,
    /// unread events the push rules said to notify about, which is neither of the above
    pub unread_notifications: u64,
    pub encrypted: bool,
    pub space: bool,
    pub direct: bool,
    pub favourite: bool,
    pub low_priority: bool,
    pub avatar: Option<OwnedMxcUri>,
    pub latest_event_timestamp_ms: Option<u64>,
    pub latest_event: Option<LatestEvent>,
    pub notification_mode: Option<RoomNotificationMode>,
    pub notification_mode_custom: bool,
    pub topic: Option<String>,
    pub canonical_alias: Option<OwnedRoomAliasId>,
    pub joined_members: u64,
    pub invited_members: u64,
    /// who a nameless room gets named after
    pub heroes: Vec<RoomHero>,
    /// set once the room has been upgraded, this is where everyone went
    pub successor: Option<OwnedRoomId>,
    pub inviter: Option<OwnedUserId>,
    /// joined spaces that list this room as a child
    pub parent_spaces: Vec<OwnedRoomId>,
    /// for a space, the children it lists, joined or not
    pub children: Vec<OwnedRoomId>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct RoomHero {
    pub user_id: OwnedUserId,
    pub display_name: Option<String>,
    pub avatar: Option<OwnedMxcUri>,
}

/// enough for a room list preview line. `kind` and `body` are only set for messages,
/// and an edit shows its new text
#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct LatestEvent {
    pub sender: Option<OwnedUserId>,
    pub kind: Option<MessageKind>,
    pub body: Option<String>,
    pub timestamp_ms: Option<u64>,
    pub send_state: SendState,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct Profile {
    pub user_id: OwnedUserId,
    pub display_name: Option<String>,
    pub avatar: Option<OwnedMxcUri>,
}

/// one room in a space's hierarchy, as the server describes it, which may be a room you're not in
#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct SpaceChild {
    pub room_id: OwnedRoomId,
    pub name: String,
    pub topic: Option<String>,
    pub avatar: Option<OwnedMxcUri>,
    pub canonical_alias: Option<OwnedRoomAliasId>,
    pub joined_members: u64,
    pub space: bool,
    pub children_count: u64,
    pub membership: Option<RoomMembership>,
    pub via: Vec<OwnedServerName>,
    pub suggested: bool,
    pub world_readable: Option<bool>,
    pub guest_can_join: bool,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum RoomNotificationMode {
    AllMessages,
    MentionsAndKeywordsOnly,
    Mute,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct RoomNotificationSettings {
    pub mode: RoomNotificationMode,
    pub custom: bool,
}

#[derive(Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum PushNotificationStatus {
    Event(Box<PushNotification>),
    NotFound,
    FilteredOut,
    Redacted,
}

#[derive(Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct PushNotification {
    pub event_id: OwnedEventId,
    pub event: PushNotificationEvent,
    pub sender: PushNotificationSender,
    pub room: PushNotificationRoom,
    pub noisy: Option<bool>,
    pub has_mention: Option<bool>,
    pub thread_id: Option<OwnedEventId>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct PushNotificationSender {
    pub user_id: OwnedUserId,
    pub display_name: Option<String>,
    pub avatar_url: Option<OwnedMxcUri>,
    pub name_ambiguous: bool,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct PushNotificationRoom {
    pub room_id: OwnedRoomId,
    pub name: String,
    pub avatar_url: Option<OwnedMxcUri>,
    pub canonical_alias: Option<OwnedRoomAliasId>,
    pub topic: Option<String>,
    pub encrypted: Option<bool>,
    pub direct: bool,
    pub joined_members_count: u64,
    pub service_members: Vec<OwnedUserId>,
    pub active_service_members_count: u64,
    pub space: bool,
}

#[derive(Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum PushNotificationEvent {
    Timeline(Raw<AnySyncTimelineEvent>),
    Invite(Raw<StrippedRoomMemberEvent>),
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct RoomPowerLevels {
    pub ban: i64,
    pub invite: i64,
    pub kick: i64,
    pub redact: i64,
    pub events_default: i64,
    pub state_default: i64,
    pub users_default: i64,
    pub room_notification: i64,
    pub users: Vec<(OwnedUserId, i64)>,
    pub events: Vec<(String, i64)>,
    /// in rooms from version 12 the creators outrank everyone and aren't listed in `users`
    pub creators: Vec<OwnedUserId>,
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct PowerLevelChanges {
    pub ban: Option<i64>,
    pub invite: Option<i64>,
    pub kick: Option<i64>,
    pub redact: Option<i64>,
    pub events_default: Option<i64>,
    pub state_default: Option<i64>,
    pub users_default: Option<i64>,
    pub room_notification: Option<i64>,
    pub room_name: Option<i64>,
    pub room_avatar: Option<i64>,
    pub room_topic: Option<i64>,
    pub space_child: Option<i64>,
    pub beacon: Option<i64>,
    pub beacon_info: Option<i64>,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum RoomMembership {
    Joined,
    Invited,
    Left,
    Knocked,
    Banned,
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct RoomListFilter {
    pub membership: Option<RoomMembership>,
    pub category: Option<RoomCategory>,
    pub favourite: Option<bool>,
    pub unread_only: bool,
    pub search: Option<String>,
}

impl RoomListFilter {
    #[must_use]
    pub fn with_membership(mut self, membership: RoomMembership) -> Self {
        self.membership = Some(membership);
        self
    }

    #[must_use]
    pub fn with_category(mut self, category: RoomCategory) -> Self {
        self.category = Some(category);
        self
    }

    #[must_use]
    pub fn with_favourite(mut self, favourite: bool) -> Self {
        self.favourite = Some(favourite);
        self
    }

    #[must_use]
    pub const fn with_unread_only(mut self, unread_only: bool) -> Self {
        self.unread_only = unread_only;
        self
    }

    #[must_use]
    pub fn with_search(mut self, search: impl Into<String>) -> Self {
        self.search = Some(search.into());
        self
    }

    #[must_use]
    pub fn matches(&self, room: &RoomSummary) -> bool {
        self.matcher().matches(room)
    }

    /// lowercases the search once, for filtering a whole list
    #[must_use]
    pub fn matcher(&self) -> RoomMatcher<'_> {
        RoomMatcher {
            filter: self,
            search: self.search.as_deref().map(str::to_lowercase),
        }
    }
}

#[derive(Debug)]
pub struct RoomMatcher<'a> {
    filter: &'a RoomListFilter,
    search: Option<String>,
}

impl RoomMatcher<'_> {
    #[must_use]
    pub fn matches(&self, room: &RoomSummary) -> bool {
        let filter = self.filter;
        filter
            .membership
            .is_none_or(|membership| room.membership == membership)
            && filter.category.is_none_or(|category| match category {
                RoomCategory::People => room.direct && !room.space,
                RoomCategory::Rooms => !room.direct && !room.space,
                RoomCategory::Spaces => room.space,
            })
            && filter
                .favourite
                .is_none_or(|favourite| room.favourite == favourite)
            && (!filter.unread_only || room.unread_messages > 0 || room.unread_mentions > 0)
            && self.search.as_ref().is_none_or(|search| {
                room.name.to_lowercase().contains(search)
                    || room.room_id.as_str().to_lowercase().contains(search)
            })
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum RoomCategory {
    People,
    Rooms,
    Spaces,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum MemberFilter {
    Active,
    Joined,
    Invited,
    Banned,
    Left,
    All,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum MemberMembership {
    Joined,
    Invited,
    Left,
    Knocked,
    Banned,
    Custom(String),
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct MemberSummary {
    pub user_id: OwnedUserId,
    pub name: String,
    pub display_name: Option<String>,
    pub avatar: Option<OwnedMxcUri>,
    pub membership: MemberMembership,
    pub own: bool,
    pub name_ambiguous: bool,
    pub ignored: bool,
    pub service: bool,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct OwnDevice {
    pub device_id: OwnedDeviceId,
    pub display_name: Option<String>,
    pub last_seen_ip: Option<String>,
    pub last_seen_timestamp_ms: Option<u64>,
    pub current: bool,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum TimelineItem {
    Event(Box<TimelineEvent>),
    DayDivider { timestamp_ms: u64 },
    ReadMarker,
    TimelineStart,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum TimelineDiff {
    Append { values: Vec<TimelineItem> },
    Clear,
    PushFront { value: TimelineItem },
    PushBack { value: TimelineItem },
    PopFront,
    PopBack,
    Insert { index: usize, value: TimelineItem },
    Set { index: usize, value: TimelineItem },
    Remove { index: usize },
    Truncate { length: usize },
    Reset { values: Vec<TimelineItem> },
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, thiserror::Error)]
#[error("timeline diff is incompatible with the current {length}-item snapshot")]
pub struct TimelineDiffError {
    pub length: usize,
}

impl TimelineDiff {
    /// Apply a diff only when its indices match the current snapshot.
    /// On error the snapshot is unchanged; request `TimelineCommand::Resync`
    /// and ignore further diffs until the corresponding `TimelineReset`.
    pub fn try_apply(self, items: &mut Vector<TimelineItem>) -> Result<(), TimelineDiffError> {
        let length = items.len();
        if self.length_after(length).is_none() {
            return Err(TimelineDiffError { length });
        }
        self.apply(items);
        Ok(())
    }

    /// a whole `TimelineChanged` or none of it. whether a diff fits depends only on the
    /// length before it, so the batch is checked against lengths alone before anything
    /// moves. the error carries the length the snapshot would have had at the misfit
    pub fn try_apply_all(
        diffs: Vec<Self>,
        items: &mut Vector<TimelineItem>,
    ) -> Result<(), TimelineDiffError> {
        diffs.iter().try_fold(items.len(), |length, diff| {
            diff.length_after(length)
                .ok_or(TimelineDiffError { length })
        })?;
        for diff in diffs {
            diff.apply(items);
        }
        Ok(())
    }

    fn length_after(&self, length: usize) -> Option<usize> {
        match self {
            Self::Append { values } => Some(length + values.len()),
            Self::Clear => Some(0),
            Self::PushFront { .. } | Self::PushBack { .. } => Some(length + 1),
            Self::PopFront | Self::PopBack => length.checked_sub(1),
            Self::Insert { index, .. } => (*index <= length).then_some(length + 1),
            Self::Set { index, .. } => (*index < length).then_some(length),
            Self::Remove { index } => (*index < length).then(|| length - 1),
            Self::Truncate { length: target } => (*target <= length).then_some(*target),
            Self::Reset { values } => Some(values.len()),
        }
    }

    fn apply(self, items: &mut Vector<TimelineItem>) {
        match self {
            Self::Append { values } => items.extend(values),
            Self::Clear => items.clear(),
            Self::PushFront { value } => items.push_front(value),
            Self::PushBack { value } => items.push_back(value),
            Self::PopFront => {
                items.pop_front();
            }
            Self::PopBack => {
                items.pop_back();
            }
            Self::Insert { index, value } => items.insert(index, value),
            Self::Set { index, value } => {
                items.set(index, value);
            }
            Self::Remove { index } => {
                items.remove(index);
            }
            Self::Truncate { length } => items.truncate(length),
            Self::Reset { values } => *items = values.into_iter().collect(),
        }
    }
}

#[cfg(test)]
mod tests {
    use imbl::{Vector, vector};

    use super::{TimelineDiff, TimelineItem};

    fn item(timestamp_ms: u64) -> TimelineItem {
        TimelineItem::DayDivider { timestamp_ms }
    }

    #[test]
    fn timeline_diff_try_apply_handles_every_variant() {
        let mut items = vector![item(1), item(2)];

        TimelineDiff::Append {
            values: vec![item(3)],
        }
        .try_apply(&mut items)
        .unwrap();
        assert_eq!(items, vector![item(1), item(2), item(3)]);

        TimelineDiff::Clear.try_apply(&mut items).unwrap();
        assert!(items.is_empty());

        TimelineDiff::PushFront { value: item(2) }
            .try_apply(&mut items)
            .unwrap();
        TimelineDiff::PushBack { value: item(3) }
            .try_apply(&mut items)
            .unwrap();
        assert_eq!(items, vector![item(2), item(3)]);

        TimelineDiff::PopFront.try_apply(&mut items).unwrap();
        TimelineDiff::PopBack.try_apply(&mut items).unwrap();
        assert!(items.is_empty());

        TimelineDiff::Reset {
            values: vec![item(1), item(3)],
        }
        .try_apply(&mut items)
        .unwrap();
        TimelineDiff::Insert {
            index: 1,
            value: item(2),
        }
        .try_apply(&mut items)
        .unwrap();
        assert_eq!(items, vector![item(1), item(2), item(3)]);

        TimelineDiff::Set {
            index: 1,
            value: item(4),
        }
        .try_apply(&mut items)
        .unwrap();
        assert_eq!(items, vector![item(1), item(4), item(3)]);

        TimelineDiff::Remove { index: 1 }
            .try_apply(&mut items)
            .unwrap();
        assert_eq!(items, vector![item(1), item(3)]);

        TimelineDiff::Truncate { length: 1 }
            .try_apply(&mut items)
            .unwrap();
        assert_eq!(items, vector![item(1)]);
    }

    #[test]
    fn invalid_timeline_diff_leaves_snapshot_unchanged() {
        let invalid = [
            TimelineDiff::Insert {
                index: 3,
                value: item(3),
            },
            TimelineDiff::Set {
                index: 2,
                value: item(3),
            },
            TimelineDiff::Remove { index: 2 },
            TimelineDiff::Truncate { length: 3 },
        ];
        for diff in invalid {
            let mut items = vector![item(1), item(2)];
            assert_eq!(diff.try_apply(&mut items).unwrap_err().length, 2);
            assert_eq!(items, vector![item(1), item(2)]);
        }
        for diff in [TimelineDiff::PopFront, TimelineDiff::PopBack] {
            let mut items = Vector::new();
            assert_eq!(diff.try_apply(&mut items).unwrap_err().length, 0);
            assert!(items.is_empty());
        }
    }

    #[test]
    fn a_batch_that_goes_wrong_halfway_changes_nothing() {
        let mut items = vector![item(1), item(2)];
        let batch = vec![
            TimelineDiff::PushBack { value: item(3) },
            TimelineDiff::Remove { index: 0 },
            TimelineDiff::Set {
                index: 2,
                value: item(4),
            },
        ];
        assert_eq!(
            TimelineDiff::try_apply_all(batch, &mut items)
                .unwrap_err()
                .length,
            2
        );
        assert_eq!(items, vector![item(1), item(2)]);

        let batch = vec![
            TimelineDiff::PushBack { value: item(3) },
            TimelineDiff::Remove { index: 0 },
            TimelineDiff::Set {
                index: 1,
                value: item(4),
            },
        ];
        TimelineDiff::try_apply_all(batch, &mut items).unwrap();
        assert_eq!(items, vector![item(2), item(4)]);
    }
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct TimelineItemId(String);

impl TimelineItemId {
    pub(crate) fn new(value: String) -> Self {
        Self(value)
    }

    #[must_use]
    pub fn as_str(&self) -> &str {
        &self.0
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct TimelineEvent {
    pub item_id: TimelineItemId,
    pub event_id: Option<OwnedEventId>,
    pub transaction_id: Option<OwnedTransactionId>,
    pub sender: Sender,
    pub timestamp_ms: u64,
    pub own: bool,
    pub send_state: SendState,
    pub content: TimelineContent,
    pub reply_to: Option<ReplyReference>,
    pub thread_root: Option<OwnedEventId>,
    pub thread_summary: Option<ThreadSummary>,
    pub reactions: Vec<Reaction>,
    pub read_by: Vec<OwnedUserId>,
    pub editable: bool,
}

impl TimelineEvent {
    /// what to hand edit, redact and react. works before the server has echoed it back
    #[must_use]
    pub fn target(&self) -> Option<EventRef> {
        self.event_id
            .clone()
            .map(EventRef::Remote)
            .or_else(|| self.transaction_id.clone().map(EventRef::Local))
    }
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum EventRef {
    Remote(OwnedEventId),
    /// a local echo, by the transaction id it was queued under
    Local(OwnedTransactionId),
}

impl From<OwnedEventId> for EventRef {
    fn from(event_id: OwnedEventId) -> Self {
        Self::Remote(event_id)
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct Sender {
    pub user_id: OwnedUserId,
    pub display_name: Option<String>,
    pub avatar: Option<OwnedMxcUri>,
    /// someone else in the room goes by the same name, so show the user id too
    pub name_ambiguous: bool,
}

impl Sender {
    #[must_use]
    pub fn name(&self) -> &str {
        self.display_name
            .as_deref()
            .unwrap_or_else(|| self.user_id.as_str())
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum TimelineContent {
    Message(Message),
    Sticker {
        body: String,
        media: MediaDescriptor,
    },
    Poll {
        question: String,
    },
    Redacted,
    UnableToDecrypt(UtdCause),
    Membership {
        user_id: OwnedUserId,
        display_name: Option<String>,
        change: MembershipChange,
    },
    Profile {
        user_id: OwnedUserId,
        display_name: Option<Change<Option<String>>>,
        avatar: Option<Change<Option<OwnedMxcUri>>>,
    },
    /// `None` means it was cleared, or the event was redacted
    RoomName(Option<String>),
    RoomTopic(Option<String>),
    RoomAvatar(Option<OwnedMxcUri>),
    EncryptionEnabled,
    RoomCreated,
    RoomUpgraded {
        successor: OwnedRoomId,
    },
    OtherState {
        event_type: String,
        state_key: String,
    },
    Other {
        event_type: String,
    },
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct Message {
    pub kind: MessageKind,
    pub body: String,
    /// only for `MessageKind::Location`
    pub geo_uri: Option<String>,
    pub formatted_body: Option<String>,
    pub mentions: Option<MessageMentions>,
    pub edited: bool,
    pub media: Option<MediaDescriptor>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum MessageKind {
    Text,
    Emote,
    Notice,
    ServerNotice,
    Image,
    Video,
    Audio,
    File,
    Location,
    VerificationRequest,
    Other(String),
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum MembershipChange {
    Joined,
    Left,
    Banned,
    Unbanned,
    Kicked,
    KickedAndBanned,
    Invited,
    InvitationAccepted,
    InvitationRejected,
    InvitationRevoked,
    Knocked,
    KnockAccepted,
    KnockRetracted,
    KnockDenied,
    /// nothing a person would call a change, or something the sdk couldn't make sense of
    Other,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Change<T> {
    pub old: T,
    pub new: T,
}

/// why a message couldn't be read, worth telling the user since some of these they can fix
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum UtdCause {
    Unknown,
    SentBeforeWeJoined,
    VerificationViolation,
    UnsignedDevice,
    UnknownDevice,
    HistoricalMessageAndBackupIsDisabled,
    WithheldForUnverifiedOrInsecureDevice,
    WithheldBySender,
    HistoricalMessageAndDeviceIsUnverified,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct ThreadSummary {
    pub reply_count: u32,
    pub latest_event_id: Option<OwnedEventId>,
    pub latest_event_timestamp_ms: Option<u64>,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum SendState {
    Sent,
    Sending,
    /// `will_retry` means macltok has it in hand. otherwise it's wedged until you
    /// `retry_send` or `cancel_send`, so that's when to show a retry button
    Failed {
        will_retry: bool,
    },
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct ReplyReference {
    pub event_id: OwnedEventId,
    pub details: ReplyDetails,
}

/// the replied-to event. macltok asks for it when it isn't loaded, `Pending` then turns into one of the others
#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum ReplyDetails {
    Pending,
    Ready {
        sender: Sender,
        content: Box<TimelineContent>,
        timestamp_ms: u64,
    },
    Unavailable,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct Reaction {
    pub key: String,
    pub count: usize,
    pub own: bool,
    pub senders: Vec<OwnedUserId>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct MediaDescriptor {
    pub id: MediaId,
    pub kind: MediaKind,
    pub filename: String,
    pub caption: Option<String>,
    pub mimetype: Option<String>,
    pub size_bytes: Option<u64>,
    pub width: Option<u64>,
    pub height: Option<u64>,
    pub duration_ms: Option<u64>,
    pub blurhash: Option<String>,
    /// the uploader sent a thumbnail, so `MediaSize::Thumbnail` won't need the server to resize
    pub has_thumbnail: bool,
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct MediaId(String);

impl MediaId {
    pub(crate) fn new(value: String) -> Self {
        Self(value)
    }

    #[must_use]
    pub fn as_str(&self) -> &str {
        &self.0
    }
}

/// media ids are opaque but they do have to survive a trip through a browser. a made up one just fails `MediaUnknown`
impl std::str::FromStr for MediaId {
    type Err = std::convert::Infallible;

    fn from_str(value: &str) -> Result<Self, Self::Err> {
        Ok(Self(value.to_owned()))
    }
}

impl From<String> for MediaId {
    fn from(value: String) -> Self {
        Self(value)
    }
}

impl std::fmt::Display for MediaId {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}

#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum MediaSize {
    Full,
    /// a hint. an uploader's own thumbnail wins over the server resizing anything
    Thumbnail {
        width: u32,
        height: u32,
    },
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub struct Media {
    pub bytes: Arc<[u8]>,
    pub mimetype: String,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum MediaKind {
    Image,
    Video,
    Audio,
    File,
    Sticker,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct TypingState {
    pub room_id: OwnedRoomId,
    pub users: Vec<OwnedUserId>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum HistoryState {
    Idle,
    Loading,
    StartReached,
    Failed(String),
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct EncryptionState {
    pub device_id: OwnedDeviceId,
    pub device_verified: bool,
    pub recovery: RecoveryState,
    pub key_backup: KeyBackupState,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum KeyBackupState {
    Unknown,
    Creating,
    Enabling,
    Resuming,
    Downloading,
    Enabled,
    Disabling,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum RecoveryState {
    Unknown,
    Disabled,
    Incomplete,
    Enabled,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum VerificationAction {
    /// take up a request another device sent, which arrives as `VerificationState::Incoming`
    Accept,
    Confirm,
    Reject,
    Cancel,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum VerificationTarget {
    OwnIdentity,
    User(OwnedUserId),
    Device {
        user_id: OwnedUserId,
        device_id: OwnedDeviceId,
    },
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum VerificationState {
    Waiting,
    /// someone else asked. `Accept` to go ahead, `Cancel` to turn them down
    Incoming {
        user_id: OwnedUserId,
        device_id: Option<OwnedDeviceId>,
    },
    Comparison {
        emojis: Vec<(String, String)>,
        decimals: (u16, u16, u16),
    },
    Confirmed,
    Done,
    Cancelled(String),
    Failed(VerificationFailure),
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum VerificationFailure {
    RequestAcceptance(String),
    SasStartup(String),
    SasAcceptance(String),
    RequestStreamEnded,
    SasStreamEnded,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub struct EngineFailure {
    pub kind: EngineErrorKind,
    pub message: String,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[non_exhaustive]
pub enum EngineErrorKind {
    EventReceiverClosed,
    Watcher,
    Other,
}