macltok

use std::{

    fmt,

    future::Future,

    pin::Pin,

    sync::Arc,

    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, MxcUri, 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, EventRef, InteractiveAuth,

    InteractiveAuthOutcome, LifecycleCommand, Media, MediaCommand, MediaId, MediaLocation,

    MediaSize, MemberFilter, MemberSummary, MessageContent, MessageEditContent,

    NotificationCommand, OwnDevice, PowerLevelChanges, Profile, PushNotification,

    PushNotificationEvent, PushNotificationStatus, RoomCommand, RoomListFilter,

    RoomNotificationMode, RoomNotificationSettings, RoomPowerLevels, RoomSummary, SpaceChild,

    TimelineCommand, TimelineId, VerificationAction, VerificationTarget,

    encryption::encryption_state,

    engine::{MediaService, StoreLock},

    model::{PushNotificationRoom, PushNotificationSender},

    normalise::{member_summary, room_summaries, space_child},

};

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

    _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

    }

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

        timeline_id: TimelineId,

        target: impl Into<EventRef>,

        reason: Option<String>,

    ) -> Result<(), Error> {

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

            timeline_id,

            target: target.into(),

            reason,

        }))

        .await

    }

    pub async fn toggle_reaction(

        &self,

        timeline_id: TimelineId,

        target: impl Into<EventRef>,

        key: impl Into<String>,

    ) -> Result<(), Error> {

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

            timeline_id,

            target: target.into(),

            key: key.into(),

        }))

        .await

    }

    pub async fn mark_read(

        &self,

        timeline_id: TimelineId,

        event_id: OwnedEventId,

    ) -> Result<(), Error> {

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

            timeline_id,

            event_id,

        }))

        .await

    }

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

        self.run(Command::Room(RoomCommand::SetTyping { room_id, typing }))

            .await

    }

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

        self.run(Command::Room(RoomCommand::PrepareToSend(room_id)))

            .await

    }

    pub async fn join_room(

        &self,

        room: OwnedRoomOrAliasId,

        via: Vec<OwnedServerName>,

    ) -> Result<OwnedRoomId, Error> {

        self.run_for_room(RoomCommand::Join { room, via }).await

    }

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

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

    }

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

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

    }

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

        self.run(Command::Room(RoomCommand::AcceptInvite(room_id)))

            .await

    }

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

        self.run(Command::Room(RoomCommand::RejectInvite(room_id)))

            .await

    }

    pub async fn invite_user(

        &self,

        room_id: OwnedRoomId,

        user_id: OwnedUserId,

    ) -> Result<(), Error> {

        self.run(Command::Room(RoomCommand::InviteUser { room_id, user_id }))

            .await

    }

    pub async fn kick_user(

        &self,

        room_id: OwnedRoomId,

        user_id: OwnedUserId,

        reason: Option<String>,

    ) -> Result<(), Error> {

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

            room_id,

            user_id,

            reason,

        }))

        .await

    }

    pub async fn ban_user(

        &self,

        room_id: OwnedRoomId,

        user_id: OwnedUserId,

        reason: Option<String>,

    ) -> Result<(), Error> {

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

            room_id,

            user_id,

            reason,

        }))

        .await

    }

    pub async fn unban_user(

        &self,

        room_id: OwnedRoomId,

        user_id: OwnedUserId,

        reason: Option<String>,

    ) -> Result<(), Error> {

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

            room_id,

            user_id,

            reason,

        }))

        .await

    }

    pub async fn set_power_levels(

        &self,

        room_id: OwnedRoomId,

        changes: PowerLevelChanges,

    ) -> Result<(), Error> {

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

            room_id,

            changes,

        }))

        .await

    }

    pub async fn set_user_power_level(

        &self,

        room_id: OwnedRoomId,

        user_id: OwnedUserId,

        level: i64,

    ) -> Result<(), Error> {

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

            room_id,

            user_id,

            level,

        }))

        .await

    }

    pub async fn create_room(&self, options: CreateRoomOptions) -> Result<OwnedRoomId, Error> {

        self.run_for_room(RoomCommand::Create(options)).await

    }

    /// hands back the existing dm with them if there is one

    pub async fn create_direct(&self, user_id: OwnedUserId) -> Result<OwnedRoomId, Error> {

        self.run_for_room(RoomCommand::CreateDirect(user_id)).await

    }