macltok

use std::{

    collections::HashSet,

    fmt,

    future::Future,

    pin::Pin,

    sync::{Arc, Mutex},

    task::{Context, Poll},

};

use matrix_sdk::{Client, RoomMemberships};

use matrix_sdk_ui::{

    notification_client::{

        NotificationClient, NotificationProcessSetup, NotificationStatus, RawNotificationEvent,

    },

    spaces::{SpaceRoomList, SpaceService, room_list::SpaceRoomListPaginationState},

    sync_service::SyncService,

};

use ruma::{

    EventId, OwnedDeviceId, OwnedEventId, OwnedMxcUri, OwnedRoomId, OwnedRoomOrAliasId,

    OwnedServerName, OwnedTransactionId, OwnedUserId, RoomId, UserId,

    events::{

        AnyGlobalAccountDataEventContent, AnyRoomAccountDataEvent, AnyRoomAccountDataEventContent,

        GlobalAccountDataEventType, RoomAccountDataEventType,

    },

    serde::Raw,

};

use tokio::sync::{OnceCell, mpsc, oneshot, watch};

use crate::{

    AccountCommand, AttachmentUpload, Command, CommandOutput, ConnectionState, CreateRoomOptions,

    EncryptionCommand, EncryptionState, Error, ErrorKind, Event, EventContext, EventContextCommand,

    EventContextPage, EventRef, ImagePackSource, ImagePacks, InteractiveAuth,

    InteractiveAuthOutcome, LifecycleCommand, LinkPreview, Media, MediaCommand, MediaId,

    MediaLocation, MediaSize, MemberFilter, MemberSummary, MentionKey, MentionsBoundary,

    MentionsCommand, MentionsPage, MessageContent, MessageEditContent, NotificationCommand,

    OwnDevice, PackCommand, PackImageInfo, PackUsage, Patch, PowerLevelChanges, Profile,

    PushNotification, PushNotificationEvent, PushNotificationStatus, RoomCommand, RoomListFilter,

    RoomNotificationMode, RoomNotificationSettings, RoomPowerLevels, RoomSummary,

    SavedMentionContext, SpaceChild, TimelineCommand, TimelineId, VerificationAction,

    VerificationTarget,

    encryption::encryption_state,

    engine::{MediaService, StoreLock},

    model::{PushNotificationRoom, PushNotificationSender},

    normalise::{image_packs, member_summary, room_summaries, space_child, url_previews_allowed},

};

#[derive(Clone)]

pub struct ClientHandle {

    requests: mpsc::Sender<Request>,

    client: Client,

    connection: watch::Receiver<ConnectionState>,

    notification_client: Arc<OnceCell<NotificationClient>>,

    sync_service: Arc<SyncService>,

    media: Arc<MediaService>,

    spaces: Arc<OnceCell<SpaceService>>,

    members_checked: Arc<Mutex<HashSet<OwnedRoomId>>>,

    _store_lock: Option<Arc<StoreLock>>,

}

impl fmt::Debug for ClientHandle {

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

        formatter

            .debug_struct("ClientHandle")

            .finish_non_exhaustive()

    }

}

/// a command's answer. drop it if you don't care, the command still runs

#[derive(Debug)]

#[must_use = "dropping it is fine but then you'll never know"]

pub struct Pending(oneshot::Receiver<Result<CommandOutput, Error>>);

impl Future for Pending {

    type Output = Result<CommandOutput, Error>;

    fn poll(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Self::Output> {

        Pin::new(&mut self.0)

            .poll(context)

            .map(|result| result.unwrap_or_else(|_| Err(Error::interrupted())))

    }

}

impl ClientHandle {

    /// current credentials, it holds secrets. the engine saves it for you unless the

    /// session was built `without_persistence`

    #[cfg(any(feature = "sqlite", feature = "indexeddb"))]

    pub fn session_record(&self) -> Result<crate::SessionRecord, crate::AccountError> {

        crate::account::session_record(&self.client)

    }

    /// the bearer token. it rotates on every refresh so ask again after a 401 rather than

    /// keeping it, and keep it in memory and away from all but the homeserver's media endpoints

    pub fn access_token(&self) -> Option<String> {

        self.client.access_token()

    }

    /// queue a command, waiting for room in the queue if there isn't any

    pub async fn send(&self, command: Command) -> Result<Pending, Error> {

        let (request, pending) = Request::new(command);

        self.requests

            .send(request)

            .await

            .map_err(|_| Error::interrupted())?;

        Ok(pending)

    }

    /// queue a command or fail with `QueueFull` right now

    pub fn try_send(&self, command: Command) -> Result<Pending, Error> {

        let (request, pending) = Request::new(command);

        self.requests

            .try_send(request)

            .map_err(|error| match error {

                mpsc::error::TrySendError::Full(_) => {

                    Error::new(ErrorKind::QueueFull, "the command queue is full")

                }

                mpsc::error::TrySendError::Closed(_) => Error::interrupted(),

            })?;

        Ok(pending)

    }

    /// queue a command and wait for its answer. timeline sends answer once the

    /// sdk send queue has them, delivery shows up later as the item's send state

    pub async fn execute(&self, command: Command) -> Result<CommandOutput, Error> {

        self.send(command).await?.await

    }

    async fn run(&self, command: Command) -> Result<(), Error> {

        self.execute(command).await.map(drop)

    }

    async fn run_for_room(&self, command: RoomCommand) -> Result<OwnedRoomId, Error> {

        match self.execute(Command::Room(command)).await? {

            CommandOutput::Room(room_id) => Ok(room_id),

            output => Err(Error::new(

                ErrorKind::Other,

                format!("expected a room but got {output:?}"),

            )),

        }

    }

    pub async fn shutdown(&self) -> Result<(), Error> {

        self.run(Command::Lifecycle(LifecycleCommand::Shutdown))

            .await

    }

    pub async fn logout(&self) -> Result<(), Error> {

        self.run(Command::Account(AccountCommand::Logout)).await

    }

    pub async fn delete_devices(

        &self,

        device_ids: Vec<OwnedDeviceId>,

        auth: Option<InteractiveAuth>,

    ) -> Result<InteractiveAuthOutcome, Error> {

        match self

            .run(Command::Account(AccountCommand::DeleteDevices {

                device_ids,

                auth,

            }))

            .await

        {

            Ok(()) => Ok(InteractiveAuthOutcome::Completed),

            Err(Error {

                challenge: Some(challenge),

                ..

            }) => Ok(InteractiveAuthOutcome::Challenge(*challenge)),

            Err(error) => Err(error),

        }

    }

    pub async fn rename_device(

        &self,

        device_id: OwnedDeviceId,

        display_name: impl Into<String>,

    ) -> Result<(), Error> {

        self.run(Command::Account(AccountCommand::RenameDevice {

            device_id,

            display_name: display_name.into(),

        }))

        .await

    }

    pub async fn set_global_account_data(

        &self,

        event_type: GlobalAccountDataEventType,

        content: Raw<AnyGlobalAccountDataEventContent>,

    ) -> Result<(), Error> {

        self.run(Command::Account(AccountCommand::SetAccountData {

            event_type,

            content,

        }))

        .await

    }

    pub async fn set_room_account_data(

        &self,

        room_id: OwnedRoomId,

        event_type: RoomAccountDataEventType,

        content: Raw<AnyRoomAccountDataEventContent>,

    ) -> Result<(), Error> {

        self.run(Command::Room(RoomCommand::SetAccountData {

            room_id,

            event_type,

            content,

        }))

        .await

    }

    pub async fn set_room_notification_mode(

        &self,

        room_id: OwnedRoomId,

        mode: RoomNotificationMode,

    ) -> Result<(), Error> {

        self.run(Command::Notification(NotificationCommand::SetRoomMode {

            room_id,

            mode,

        }))

        .await

    }

    pub async fn reset_room_notification_mode(&self, room_id: OwnedRoomId) -> Result<(), Error> {

        self.run(Command::Notification(NotificationCommand::ResetRoomMode(

            room_id,

        )))

        .await

    }

    pub async fn set_default_notification_mode(

        &self,

        encrypted: bool,

        one_to_one: bool,

        mode: RoomNotificationMode,

    ) -> Result<(), Error> {

        self.run(Command::Notification(NotificationCommand::SetDefaultMode {

            encrypted,

            one_to_one,

            mode,

        }))

        .await

    }

    pub async fn add_notification_keyword(&self, keyword: impl Into<String>) -> Result<(), Error> {

        self.run(Command::Notification(NotificationCommand::AddKeyword(

            keyword.into(),

        )))

        .await

    }

    pub async fn remove_notification_keyword(

        &self,

        keyword: impl Into<String>,

    ) -> Result<(), Error> {

        self.run(Command::Notification(NotificationCommand::RemoveKeyword(

            keyword.into(),

        )))

        .await

    }

    pub async fn open_room(&self, room_id: OwnedRoomId) -> Result<(), Error> {

        self.run(Command::Room(RoomCommand::Open(room_id))).await

    }

    pub async fn close_room(&self, room_id: OwnedRoomId) -> Result<(), Error> {

        self.run(Command::Room(RoomCommand::Close(room_id))).await

    }

    pub async fn open_thread(

        &self,

        room_id: OwnedRoomId,

        root_event_id: OwnedEventId,

    ) -> Result<(), Error> {

        self.run(Command::Timeline(TimelineCommand::OpenThread {

            room_id,

            root_event_id,

        }))

        .await

    }

    pub async fn close_thread(

        &self,

        room_id: OwnedRoomId,

        root_event_id: OwnedEventId,

    ) -> Result<(), Error> {

        self.run(Command::Timeline(TimelineCommand::CloseThread {

            room_id,

            root_event_id,

        }))

        .await

    }

    /// the room's pins as `TimelineId::Pinned`, kept current as they change. the room has to be open

    pub async fn open_pinned(&self, room_id: OwnedRoomId) -> Result<(), Error> {

        self.run(Command::Timeline(TimelineCommand::OpenPinned(room_id)))

            .await

    }

    pub async fn close_pinned(&self, room_id: OwnedRoomId) -> Result<(), Error> {

        self.run(Command::Timeline(TimelineCommand::ClosePinned(room_id)))

            .await

    }

    /// reads the server's list so a pin made elsewhere just before isn't dropped

    pub async fn set_pinned(

        &self,

        room_id: OwnedRoomId,

        event_id: OwnedEventId,

        pinned: bool,

    ) -> Result<(), Error> {

        self.run(Command::Room(RoomCommand::SetPinned {

            room_id,

            event_id,

            pinned,

        }))

        .await

    }

    pub async fn resync(&self, timeline_id: TimelineId) -> Result<(), Error> {

        self.run(Command::Timeline(TimelineCommand::Resync { timeline_id }))

            .await

    }

    pub async fn paginate(&self, timeline_id: TimelineId, limit: u16) -> Result<(), Error> {

        self.run(Command::Timeline(TimelineCommand::Paginate {

            timeline_id,

            limit,

        }))

        .await

    }

    pub async fn event_context(

        &self,

        room_id: &RoomId,

        event_id: &EventId,

        before_limit: u32,

        after_limit: u32,

    ) -> Result<EventContext, Error> {

        match self

            .execute(Command::EventContext(EventContextCommand::Fetch {

                room_id: room_id.to_owned(),

                event_id: event_id.to_owned(),

                before_limit: before_limit.min(50) as u16,

                after_limit: after_limit.min(50) as u16,

            }))

            .await?

        {

            CommandOutput::EventContext(context) => Ok(context),

            output => Err(unexpected("event context", &output)),

        }

    }

    pub async fn event_context_before(

        &self,

        room_id: &RoomId,

        token: &str,

        limit: u32,

    ) -> Result<EventContextPage, Error> {

        self.event_context_page(EventContextCommand::Before {

            room_id: room_id.to_owned(),

            limit: limit.min(50) as u16,

            token: token.to_owned(),

        })

        .await

    }

    pub async fn event_context_after(

        &self,

        room_id: &RoomId,

        token: &str,

        limit: u32,

    ) -> Result<EventContextPage, Error> {

        self.event_context_page(EventContextCommand::After {

            room_id: room_id.to_owned(),

            limit: limit.min(50) as u16,

            token: token.to_owned(),

        })

        .await

    }

    async fn event_context_page(

        &self,

        command: EventContextCommand,

    ) -> Result<EventContextPage, Error> {

        match self.execute(Command::EventContext(command)).await? {

            CommandOutput::EventContextPage(page) => Ok(page),

            output => Err(unexpected("event context page", &output)),

        }

    }

    pub async fn mentions_page(

        &self,

        cursor: Option<String>,

        limit: u32,

    ) -> Result<MentionsPage, Error> {

        match self

            .execute(Command::Mentions(MentionsCommand::Page {

                cursor,

                limit: limit.min(50) as u16,

            }))

            .await?

        {

            CommandOutput::MentionsPage(page) => Ok(page),

            output => Err(unexpected("mentions page", &output)),

        }

    }

    pub async fn mention_context(

        &self,

        room_id: &RoomId,

        event_id: &EventId,

    ) -> Result<SavedMentionContext, Error> {

        self.mention_context_command(MentionsCommand::Context(MentionKey {

            room_id: room_id.to_owned(),

            event_id: event_id.to_owned(),

        }))

        .await

    }

    pub async fn retry_mention_context(

        &self,

        room_id: &RoomId,

        event_id: &EventId,

    ) -> Result<SavedMentionContext, Error> {

        self.mention_context_command(MentionsCommand::RetryContext(MentionKey {

            room_id: room_id.to_owned(),

            event_id: event_id.to_owned(),

        }))

        .await

    }

    async fn mention_context_command(

        &self,

        command: MentionsCommand,

    ) -> Result<SavedMentionContext, Error> {

        match self.execute(Command::Mentions(command)).await? {

            CommandOutput::MentionContext(context) => Ok(context),

            output => Err(unexpected("mention context", &output)),

        }

    }

    pub async fn set_mentions_read(&self, keys: Vec<MentionKey>, read: bool) -> Result<(), Error> {

        self.run(Command::Mentions(MentionsCommand::SetRead { keys, read }))

            .await

    }

    pub async fn mark_mentions_read_through(

        &self,

        boundary: MentionsBoundary,

    ) -> Result<(), Error> {

        self.run(Command::Mentions(MentionsCommand::ReadThrough(boundary)))

            .await

    }

    pub async fn recover_mentions(&self) -> Result<(), Error> {

        self.run(Command::Mentions(MentionsCommand::Recover)).await

    }

    pub async fn send_message(

        &self,

        timeline_id: TimelineId,

        content: MessageContent,

    ) -> Result<(), Error> {

        self.run(Command::Timeline(TimelineCommand::Send {

            timeline_id,

            content,

        }))

        .await

    }

    pub async fn edit_message(

        &self,

        timeline_id: TimelineId,

        target: impl Into<EventRef>,

        content: MessageEditContent,

    ) -> Result<(), Error> {

        self.run(Command::Timeline(TimelineCommand::Edit {

            timeline_id,

            target: target.into(),

            content,

        }))

        .await

    }

    pub async fn redact(

        &self,