macltok

use std::{fmt, sync::Arc};

use ruma::{

    OwnedDeviceId, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId, OwnedRoomOrAliasId,

    OwnedServerName, OwnedTransactionId, OwnedUserId,

    events::{AnySyncTimelineEvent, room::member::StrippedRoomMemberEvent},

    serde::Raw,

};

#[cfg(feature = "serde")]

use serde::{Deserialize, Serialize};

#[derive(Debug, Eq, PartialEq)]

#[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, Eq, PartialEq)]

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

#[non_exhaustive]

pub enum AccountCommand {

    Logout,

    RenameDevice {

        device_id: OwnedDeviceId,

        display_name: String,

    },

    DeleteDevices {

        device_ids: Vec<OwnedDeviceId>,

        auth: Option<crate::InteractiveAuth>,

    },

}

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

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

#[non_exhaustive]

pub enum RoomCommand {

    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,

    },

}

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

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

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>,

}

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

        event_id: OwnedEventId,

        content: MessageEditContent,

    },

    Redact {

        timeline_id: TimelineId,

        event_id: OwnedEventId,

        reason: Option<String>,

    },

    ToggleReaction {

        timeline_id: TimelineId,

        event_id: OwnedEventId,

        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 {

    Fetch {

        id: MediaId,

        size: MediaSize,

    },

    Upload {

        timeline_id: TimelineId,

        filename: String,

        mimetype: String,

        bytes: Vec<u8>,

        caption: Option<String>,

    },

    UploadAttachment(AttachmentUpload),

}

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

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

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))]

pub struct UploadThumbnail {

    pub bytes: Vec<u8>,

    pub mimetype: String,

    pub width: u32,

    pub height: u32,

}

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

}

impl Command {

    #[must_use]

    pub const fn kind(&self) -> CommandKind {

        match self {

            Self::Account(_) => CommandKind::Account,

            Self::Room(_) => CommandKind::Room,

            Self::Timeline(_) => CommandKind::Timeline,

            Self::Media(_) => CommandKind::Media,

            Self::Encryption(_) => CommandKind::Encryption,

            Self::Notification(_) => CommandKind::Notification,

            Self::Lifecycle(_) => CommandKind::Lifecycle,

        }

    }

}

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

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

pub enum CommandKind {

    Account,

    Room,

    Timeline,

    Media,

    Encryption,

    Notification,

    Lifecycle,

}

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