macltok

use std::{collections::BTreeMap, 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),

    EventContext(EventContextCommand),

    Mentions(crate::MentionsCommand),

    Media(MediaCommand),

    Encryption(EncryptionCommand),

    Notification(NotificationCommand),

    Lifecycle(LifecycleCommand),

    Pack(PackCommand),

    HistoryRepair(crate::HistoryRepairCommand),

    ThreadList(ThreadListCommand),

}

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

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

#[non_exhaustive]

pub enum EventContextCommand {

    /// opens a session that owns the media of everything it hands out. at most 32 stay

    /// open, opening another closes the oldest, and leaving the room closes its sessions,

    /// both told with `Event::EventContextClosed`

    Fetch {

        room_id: OwnedRoomId,

        event_id: OwnedEventId,

        before_limit: u16,

        after_limit: u16,

    },

    Before {

        context_id: String,

        limit: u16,

        token: String,

    },

    After {

        context_id: String,

        limit: u16,

        token: String,

    },

    /// frees the session's media. its rows' media ids stop resolving

    Close { context_id: String },

}

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

    },

    /// pinning appends, so the newest pin is last like everywhere else

    SetPinned {

        room_id: OwnedRoomId,

        event_id: OwnedEventId,

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

    },

    /// the room's pinned events as a timeline of their own, kept current as pins change.

    /// it can't send or paginate, the pins are all it holds

    OpenPinned(OwnedRoomId),

    ClosePinned(OwnedRoomId),

    /// 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, .. }

            | Self::OpenPinned(room_id)

            | Self::ClosePinned(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 { .. }

            | Self::OpenPinned(_)

            | Self::ClosePinned(_) => 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))]

pub enum TimelineId {

    Room(OwnedRoomId),

    Thread {

        room_id: OwnedRoomId,

        root_event_id: OwnedEventId,

    },

    Pinned(OwnedRoomId),

}

impl TimelineId {

    #[must_use]

    pub const fn room_id(&self) -> &OwnedRoomId {

        match self {

            Self::Room(room_id) | Self::Thread { room_id, .. } | Self::Pinned(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(_) | Self::Pinned(_) => 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),

}

/// a room's threads, newest activity first, kept current as they gain replies. the room

/// needn't be open

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

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

#[non_exhaustive]

pub enum ThreadListCommand {

    /// answers once `ThreadListReset` has gone out, empty until a page arrives. opening an

    /// open list sends a fresh reset

    Open(OwnedRoomId),

    /// the next `limit` threads from the server, at most 50. one page runs at a time and a

    /// second ask waits for it

    Paginate {

        room_id: OwnedRoomId,

        limit: u16,

    },

    Close(OwnedRoomId),

}

/// msc2545 pack editing. edits read the server's copy and keep keys macltok doesn't model

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

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

#[non_exhaustive]

pub enum PackCommand {

    /// body defaults to the shortcode

    /// into a thread with the thread relation. the pinned timeline refuses it

    SendSticker {

        timeline_id: TimelineId,

        pack_id: String,

        shortcode: String,

    },

    /// fails if the state key already holds a pack

    CreateRoomPack {

        room_id: OwnedRoomId,

        state_key: String,

        display_name: String,

    },

    /// empties the content, which is all deleting a pack can mean

    Delete(ImagePackSource),

    SetMeta {

        pack: ImagePackSource,

        display_name: Patch<String>,

        avatar: Patch<OwnedMxcUri>,

        usage: Patch<Vec<PackUsage>>,

    },

    /// adds or replaces by shortcode. a replaced image keeps its info unless the url changed

    PutImage {

        pack: ImagePackSource,

        shortcode: String,

        mxc: OwnedMxcUri,

        body: Option<String>,

        usage: Option<Vec<PackUsage>>,

        info: Option<PackImageInfo>,

    },

    /// fails if `to` is taken

    RenameImage {

        pack: ImagePackSource,

        from: String,

        to: String,

    },

    RemoveImage {

        pack: ImagePackSource,

        shortcode: String,

    },

    SetEnabledEverywhere {

        room_id: OwnedRoomId,

        state_key: String,

        enabled: bool,

    },

    /// answers with `CommandOutput::Mxc`, the same uri when it already lives on your homeserver

    Rehost(OwnedMxcUri),

    /// the rest answer with `CommandOutput::Cloned`. clashes get `-2`, `-3` and so on

    CloneImage {

        from_pack: String,

        shortcode: String,

        to: ImagePackSource,

        usage: Option<Vec<PackUsage>>,

    },

    CloneSticker {

        room_id: OwnedRoomId,

        event_id: OwnedEventId,

        to: ImagePackSource,

        shortcode: String,

        usage: Option<Vec<PackUsage>>,

    },

    /// makes the room pack if its state key is free, else merges. images that can't be

    /// fetched are skipped and listed, the rest are written

    ClonePack {

        from_pack: String,

        to: ImagePackSource,

        display_name: Option<String>,

        usage: Option<Vec<PackUsage>>,

    },

}

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

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

pub enum Patch<T> {

    #[default]