macltok

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

use imbl::Vector;

use ruma::{

    MxcUri, OwnedDeviceId, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId,

    OwnedRoomOrAliasId, OwnedServerName, OwnedTransactionId, OwnedUserId, RoomId,

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

    },

    /// unencrypted, answers with `CommandOutput::Mxc`. same byte cap as any upload

    UploadMedia {

        mimetype: String,

        bytes: Vec<u8>,

    },

    IgnoreUser(OwnedUserId),

    UnignoreUser(OwnedUserId),

    /// writes msc3230 orders so these spaces sort in exactly this sequence, touching as few as it can

    ReorderSpaces(Vec<OwnedRoomId>),

    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,

    },

    /// muting drops them below what sending a message takes, unmuting puts a muted user back

    /// at users_default and leaves anyone else alone

    MuteUser {

        room_id: OwnedRoomId,

        user_id: OwnedUserId,

        muted: bool,

    },

    /// adding m.favourite drops m.lowpriority, the way Element does

    SetFavourite {

        room_id: OwnedRoomId,

        favourite: bool,

    },

    /// your name in one room. None goes back to your global name

    SetOwnDisplayName {

        room_id: OwnedRoomId,

        name: Option<String>,

    },

    /// your avatar in one room. None goes back to your global avatar

    SetOwnAvatar {

        room_id: OwnedRoomId,

        avatar: Option<OwnedMxcUri>,

    },

    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,

    },

    /// the key work a send into an encrypted room would otherwise start with, done now.

    /// nothing in a plain room, and a second ask joins the first

    PrepareToSend(OwnedRoomId),

    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,

        /// a custom emote's shortcode, sent along so clients without the pack can label it

        shortcode: Option<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<RichText>,

    pub mentions: MessageMentions,

    pub reply_to: Option<OwnedEventId>,

    pub notify_replied_to: bool,

    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,

            mentions: MessageMentions::default(),

            reply_to: None,

            notify_replied_to: true,

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