macltok

use std::{future::Future, panic::AssertUnwindSafe};

use futures_util::FutureExt;

use matrix_sdk::encryption::verification::VerificationRequest;

use matrix_sdk::{

    Client,

    notification_settings::{IsEncrypted, IsOneToOne, RoomNotificationMode as SdkMode},

    ruma::{

        OwnedDeviceId, OwnedEventId, OwnedMxcUri, RoomId, TransactionId,

        api::client::{

            push::{get_pushrule, set_pushrule_actions},

            receipt::create_receipt::v3::ReceiptType,

        },

        events::receipt::ReceiptThread,

        push::{Action, HighlightTweakValue, RuleKind, Tweak},

    },

    send_queue::{LocalEchoContent, SendHandle},

};

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

use crate::{

    CommandOutput, EncryptionCommand, Error, ErrorKind, InteractiveAuth, InteractiveAuthChallenge,

    NotificationCommand, RecoveryKey, RoomNotificationMode, TimelineId,

    encryption::VerificationController,

    transport::{EventSender, Responder},

};

pub(super) struct Job<T> {

    pub(super) command: T,

    pub(super) reply: Responder,

}

/// a panicking command answers with an error instead of taking its worker down with it

pub(super) async fn guarded<T>(

    label: &'static str,

    work: impl Future<Output = Result<T, Error>>,

) -> Result<T, Error> {

    AssertUnwindSafe(work)

        .catch_unwind()

        .await

        .unwrap_or_else(|_| Err(Error::new(ErrorKind::Other, format!("{label} panicked"))))

}

pub(super) async fn run_notifications(

    client: Client,

    mut jobs: mpsc::Receiver<Job<NotificationCommand>>,

) {

    while let Some(Job { command, reply }) = jobs.recv().await {

        reply.done(guarded("notification command", notification(&client, command)).await);

    }

}

pub(super) async fn run_encryption(

    client: Client,

    events: EventSender,

    mut jobs: mpsc::Receiver<Job<EncryptionCommand>>,

    mut incoming: mpsc::UnboundedReceiver<VerificationRequest>,

    enabling: watch::Sender<bool>,

) {

    let mut verification = VerificationController::default();

    loop {

        tokio::select! {

            job = jobs.recv() => {

                let Some(Job { command, reply }) = job else { return };

                let work = encryption(&client, &events, &mut verification, &enabling, command);

                reply.send(guarded("encryption command", work).await);

            }

            Some(request) = incoming.recv() => {

                verification.adopt_incoming(events.clone(), request).await;

            }

        }

    }

}

async fn encryption(

    client: &Client,

    events: &EventSender,

    verification: &mut VerificationController,

    enabling: &watch::Sender<bool>,

    command: EncryptionCommand,

) -> Result<CommandOutput, Error> {

    let encryption = client.encryption();

    let recovery = encryption.recovery();

    let key = |key: String| CommandOutput::RecoveryKey(RecoveryKey::new(key));

    let done = CommandOutput::Done;

    match command {

        EncryptionCommand::EnableRecovery { passphrase } => {

            let _enabling = Enabling::start(enabling);

            let enable = recovery.enable();

            match passphrase.as_deref() {

                Some(passphrase) => enable.with_passphrase(passphrase).await,

                None => enable.await,

            }

            .map(key)

            .map_err(|source| Error::from_recovery("enabling recovery failed", source))

        }

        EncryptionCommand::ResetRecoveryKey { passphrase } => {

            let reset = recovery.reset_key();

            match passphrase.as_deref() {

                Some(passphrase) => reset.with_passphrase(passphrase).await,

                None => reset.await,

            }

            .map(key)

            .map_err(|source| Error::from_recovery("resetting the recovery key failed", source))

        }

        EncryptionCommand::DisableRecovery => recovery

            .disable()

            .await

            .map(|()| done)

            .map_err(|source| Error::from_recovery("disabling recovery failed", source)),

        EncryptionCommand::Recover(key) => recovery

            .recover(&key)

            .await

            .map(|()| done)

            .map_err(|source| Error::from_recovery("account recovery failed", source)),

        EncryptionCommand::RecoverKeyBackup(key) => recovery

            .recover_and_fix_backup(&key)

            .await

            .map(|()| done)

            .map_err(|source| Error::from_recovery("recovering key backup failed", source)),

        EncryptionCommand::CreateKeyBackup => encryption

            .backups()

            .create()

            .await

            .map(|()| done)

            .map_err(|source| Error::from_sdk("creating key backup failed", source)),

        EncryptionCommand::EnableKeyBackup => recovery

            .enable_backup()

            .await

            .map(|()| done)

            .map_err(|source| Error::from_recovery("enabling key backup failed", source)),

        EncryptionCommand::DisableKeyBackup { delete_from_server } => {

            let backups = encryption.backups();

            if delete_from_server {

                backups.disable_and_delete().await

            } else {

                backups.disable().await

            }

            .map(|()| done)

            .map_err(|source| Error::from_sdk("disabling key backup failed", source))

        }

        EncryptionCommand::StartVerification(target) => verification

            .start(client, events.clone(), target)

            .await

            .map(|()| done),

        EncryptionCommand::Verify(action) => verification

            .apply(events.clone(), action)

            .await

            .map(|()| done),

    }

}

/// a panicking enable must not leave the state saying it is still running

struct Enabling<'a>(&'a watch::Sender<bool>);

impl<'a> Enabling<'a> {

    fn start(sender: &'a watch::Sender<bool>) -> Self {

        sender.send_replace(true);

        Self(sender)

    }

}

impl Drop for Enabling<'_> {

    fn drop(&mut self) {

        self.0.send_replace(false);

    }

}

async fn notification(client: &Client, command: NotificationCommand) -> Result<(), Error> {

    let settings = client.notification_settings().await;

    match command {

        NotificationCommand::SetRoomMode { room_id, mode } => {

            settings

                .set_room_notification_mode(&room_id, sdk_mode(mode))

                .await

        }

        NotificationCommand::ResetRoomMode(room_id) => {

            settings.delete_user_defined_room_rules(&room_id).await

        }

        NotificationCommand::SetDefaultMode {

            encrypted,

            one_to_one,

            mode,

        } => {

            settings

                .set_default_room_notification_mode(

                    IsEncrypted::from(encrypted),

                    IsOneToOne::from(one_to_one),

                    sdk_mode(mode),

                )

                .await

        }

        NotificationCommand::AddKeyword(keyword) => {

            match settings.add_keyword(keyword.clone()).await {

                Ok(()) => return highlight_keyword(client, &keyword).await,

                Err(error) => Err(error),

            }

        }

        NotificationCommand::RemoveKeyword(keyword) => settings.remove_keyword(&keyword).await,

    }

    .map_err(|source| {

        Error::with_source(

            ErrorKind::Server,

            "updating notification settings failed",

            source,

        )

    })

}

/// sdk keyword rules carry only notify and a sound, while Element's loud keywords also

/// highlight, which is what lets the inbox keep them as mentions. The sdk names a

/// keyword's content rule after the keyword itself, a rule under another id is left

/// alone.

async fn highlight_keyword(client: &Client, keyword: &str) -> Result<(), Error> {

    let failed = |source| Error::from_http("highlighting a notification keyword failed", source);

    let rule = match client

        .send(get_pushrule::v3::Request::new(

            RuleKind::Content,

            keyword.to_owned(),

        ))

        .await

    {

        Ok(response) => response.rule,

        Err(error)

            if error

                .as_client_api_error()

                .is_some_and(|error| error.status_code.as_u16() == 404) =>

        {

            return Ok(());

        }

        Err(error) => return Err(failed(error)),

    };

    if rule.actions.iter().any(Action::is_highlight) {

        return Ok(());

    }

    let mut actions: Vec<_> = rule

        .actions

        .into_iter()

        .filter(|action| !matches!(action, Action::SetTweak(Tweak::Highlight(_))))

        .collect();

    actions.push(Action::SetTweak(Tweak::Highlight(HighlightTweakValue::Yes)));

    client

        .send(set_pushrule_actions::v3::Request::new(

            RuleKind::Content,

            keyword.to_owned(),

            actions,

        ))

        .await

        .map_err(failed)?;

    Ok(())

}

const fn sdk_mode(mode: RoomNotificationMode) -> SdkMode {

    match mode {

        RoomNotificationMode::AllMessages => SdkMode::AllMessages,

        RoomNotificationMode::MentionsAndKeywordsOnly => SdkMode::MentionsAndKeywordsOnly,

        RoomNotificationMode::Mute => SdkMode::Mute,

    }

}

fn room(client: &Client, room_id: &RoomId) -> Result<matrix_sdk::Room, Error> {

    client.get_room(room_id).ok_or_else(Error::room_unknown)

}

/// the closed-room path. without a timeline nothing stops the marker going backwards

pub(super) async fn mark_read(

    client: &Client,

    timeline_id: &TimelineId,

    event_id: OwnedEventId,

) -> Result<(), Error> {

    let room = room(client, timeline_id.room_id())?;

    let receipt_failed = |source| Error::from_sdk("sending read receipt failed", source);

    let thread = match timeline_id.thread_root() {

        None => ReceiptThread::Main,

        Some(root) => ReceiptThread::Thread(root.clone()),

    };

    room.send_single_receipt(ReceiptType::Read, thread, event_id.clone())

        .await

        .map_err(receipt_failed)?;

    if timeline_id.thread_root().is_none() {

        room.send_single_receipt(ReceiptType::FullyRead, ReceiptThread::Unthreaded, event_id)

            .await

            .map_err(receipt_failed)?;

    }

    Ok(())

}

pub(super) async fn set_typing(

    client: &Client,

    room_id: &RoomId,

    typing: bool,

) -> Result<(), Error> {

    room(client, room_id)?

        .typing_notice(typing)

        .await

        .map_err(|source| Error::from_sdk("typing update failed", source))

}

async fn send_handle(

    client: &Client,

    room_id: &RoomId,

    transaction_id: &TransactionId,

) -> Result<SendHandle, Error> {

    let (echoes, _) = room(client, room_id)?

        .send_queue()

        .subscribe()

        .await

        .map_err(|source| {

            Error::with_source(ErrorKind::Store, "reading send queue failed", source)

        })?;

    echoes

        .into_iter()

        .find_map(|echo| match echo.content {

            LocalEchoContent::Event { send_handle, .. }

                if echo.transaction_id.as_str() == transaction_id.as_str() =>

            {

                Some(send_handle)

            }

            _ => None,

        })

        .ok_or_else(|| {

            Error::new(

                ErrorKind::Invalid,

                "send is no longer pending or is not a message",

            )

        })

}

pub(super) async fn cancel_send(

    client: &Client,

    room_id: &RoomId,

    transaction_id: &TransactionId,

) -> Result<(), Error> {

    match send_handle(client, room_id, transaction_id)

        .await?

        .abort()

        .await

    {

        Ok(true) => Ok(()),

        Ok(false) => Err(Error::new(

            ErrorKind::Invalid,

            "send could not be cancelled because it has already been sent",

        )),

        Err(source) => Err(Error::with_source(

            ErrorKind::Store,

            "cancelling send failed",

            source,

        )),

    }

}

pub(super) async fn retry_send(

    client: &Client,

    room_id: &RoomId,

    transaction_id: &TransactionId,

) -> Result<(), Error> {

    send_handle(client, room_id, transaction_id)

        .await?

        .unwedge()

        .await

        .map_err(|source| Error::with_source(ErrorKind::Store, "retrying send failed", source))?;

    room(client, room_id)?.send_queue().set_enabled(true);

    Ok(())

}

pub(super) async fn upload_avatar(

    client: &Client,

    mimetype: &str,

    bytes: Vec<u8>,

    max_bytes: usize,

) -> Result<(), Error> {

    if bytes.len() > max_bytes {

        return Err(Error::new(

            ErrorKind::MediaTooLarge,

            "avatar exceeds the configured byte limit",

        ));

    }

    let mimetype: mime::Mime = mimetype

        .parse()

        .map_err(|_| Error::new(ErrorKind::Invalid, "avatar MIME type is invalid"))?;

    if mimetype.type_() != mime::IMAGE {

        return Err(Error::new(

            ErrorKind::Invalid,

            "an avatar has to be an image",

        ));

    }

    client

        .account()

        .upload_avatar(&mimetype, bytes)

        .await

        .map(drop)

        .map_err(|source| Error::from_sdk("uploading avatar failed", source))

}

pub(super) async fn upload_media(

    client: &Client,

    mimetype: &str,

    bytes: Vec<u8>,

    max_bytes: usize,

) -> Result<OwnedMxcUri, Error> {

    if bytes.len() > max_bytes {

        return Err(Error::new(

            ErrorKind::MediaTooLarge,

            "media exceeds the configured byte limit",

        ));

    }

    let mimetype: mime::Mime = mimetype

        .parse()

        .map_err(|_| Error::new(ErrorKind::Invalid, "media MIME type is invalid"))?;

    client

        .media()

        .upload(&mimetype, bytes, None)

        .await

        .map(|response| response.content_uri)

        .map_err(|source| Error::from_sdk("uploading media failed", source))

}

pub(super) async fn rename_device(

    client: &Client,

    device_id: &OwnedDeviceId,

    display_name: &str,

) -> Result<(), Error> {

    client

        .rename_device(device_id, display_name)

        .await

        .map(drop)

        .map_err(|source| Error::from_http("renaming device failed", source))

}

pub(super) async fn delete_devices(

    client: &Client,

    device_ids: &[OwnedDeviceId],

    auth: Option<InteractiveAuth>,

) -> Result<(), Error> {

    let user_id = client

        .user_id()

        .ok_or_else(|| Error::new(ErrorKind::Unauthenticated, "the client is not logged in"))?;

    let auth = auth

        .map(|auth| auth.into_sdk(user_id))

        .transpose()

        .map_err(|message| {

            Error::new(

                ErrorKind::Invalid,

                format!("interactive authentication data is invalid, {message}"),

            )

        })?;

    match client.delete_devices(device_ids, auth).await {

        Ok(_) => Ok(()),

        Err(source) => match source.as_uiaa_response() {

            Some(info) => Err(Error::interactive_auth(InteractiveAuthChallenge::from(

                info,

            ))),

            None => Err(Error::from_http("deleting devices failed", source)),

        },

    }

}