matrix-rust-sdk

// Copyright 2023 The Matrix.org Foundation C.I.C.

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

use std::{

    collections::{BTreeSet, HashMap},

    sync::Arc,

    time::Duration,

};

use extension_trait::extension_trait;

use matrix_sdk::attachment::{BaseAudioInfo, BaseFileInfo, BaseImageInfo, BaseVideoInfo};

use ruma::{

    KeyDerivationAlgorithm as RumaKeyDerivationAlgorithm, MatrixToUri, MatrixUri as RumaMatrixUri,

    OwnedRoomId, OwnedUserId, UInt, UserId, assign,

    events::{

        GlobalAccountDataEvent as RumaGlobalAccountDataEvent,

        GlobalAccountDataEventType as RumaGlobalAccountDataEventType,

        RoomAccountDataEvent as RumaRoomAccountDataEvent,

        RoomAccountDataEventType as RumaRoomAccountDataEventType,

        direct::DirectEventContent,

        fully_read::FullyReadEventContent,

        identity_server::IdentityServerEventContent,

        ignored_user_list::{IgnoredUser as RumaIgnoredUser, IgnoredUserListEventContent},

        location::AssetType as RumaAssetType,

        marked_unread::{MarkedUnreadEventContent, UnstableMarkedUnreadEventContent},

        media_preview_config::{

            InviteAvatars as RumaInviteAvatars, MediaPreviewConfigEventContent,

            MediaPreviews as RumaMediaPreviews,

        },

        poll::start::PollKind as RumaPollKind,

        push_rules::PushRulesEventContent,

        room::{

            ImageInfo as RumaImageInfo, MediaSource as RumaMediaSource,

            ThumbnailInfo as RumaThumbnailInfo,

            message::{

                AudioInfo as RumaAudioInfo,

                AudioMessageEventContent as RumaAudioMessageEventContent,

                EmoteMessageEventContent as RumaEmoteMessageEventContent, FileInfo as RumaFileInfo,

                FileMessageEventContent as RumaFileMessageEventContent,

                FormattedBody as RumaFormattedBody,

                ImageMessageEventContent as RumaImageMessageEventContent,

                LocationMessageEventContent as RumaLocationMessageEventContent,

                MessageType as RumaMessageType,

                NoticeMessageEventContent as RumaNoticeMessageEventContent,

                RoomMessageEventContentWithoutRelation,

                TextMessageEventContent as RumaTextMessageEventContent, UnstableAmplitude,

                UnstableAudioDetailsContentBlock as RumaUnstableAudioDetailsContentBlock,

                UnstableVoiceContentBlock as RumaUnstableVoiceContentBlock,

                VideoInfo as RumaVideoInfo,

                VideoMessageEventContent as RumaVideoMessageEventContent,

            },

        },

        rtc::notification::{

            CallIntent as RumaCallIntent, NotificationType as RumaNotificationType,

        },

        secret_storage::{

            default_key::SecretStorageDefaultKeyEventContent,

            key::{

                PassPhrase as RumaPassPhrase,

                SecretStorageEncryptionAlgorithm as RumaSecretStorageEncryptionAlgorithm,

                SecretStorageKeyEventContent,

                SecretStorageV1AesHmacSha2Properties as RumaSecretStorageV1AesHmacSha2Properties,

            },

        },

        tag::{

            TagEventContent, TagInfo as RumaTagInfo, TagName as RumaTagName,

            UserTagName as RumaUserTagName,

        },

    },

    matrix_uri::MatrixId as RumaMatrixId,

    push::{

        ConditionalPushRule as RumaConditionalPushRule, PatternedPushRule as RumaPatternedPushRule,

        Ruleset as RumaRuleset, SimplePushRule as RumaSimplePushRule,

    },

    serde::JsonObject,

};

use tracing::info;

use crate::{

    error::{ClientError, MediaInfoError},

    helpers::unwrap_or_clone_arc,

    notification_settings::{Action, PushCondition},

    timeline::MessageContent,

    utils::u64_to_uint,

};

#[derive(uniffi::Enum)]

pub enum AuthData {

    /// Password-based authentication (`m.login.password`).

    Password { password_details: AuthDataPasswordDetails },

}

#[derive(uniffi::Record)]

pub struct AuthDataPasswordDetails {

    /// One of the user's identifiers.

    identifier: String,

    /// The plaintext password.

    password: String,

}

impl From<AuthData> for ruma::api::client::uiaa::AuthData {

    fn from(value: AuthData) -> ruma::api::client::uiaa::AuthData {

        match value {

            AuthData::Password { password_details } => {

                let user_id = ruma::UserId::parse(password_details.identifier).unwrap();

                ruma::api::client::uiaa::AuthData::Password(ruma::api::client::uiaa::Password::new(

                    user_id.into(),

                    password_details.password,

                ))

            }

        }

    }

}

/// Parse a matrix entity from a given URI, be it either

/// a `matrix.to` link or a `matrix:` URI

#[matrix_sdk_ffi_macros::export]

pub fn parse_matrix_entity_from(uri: String) -> Option<MatrixEntity> {

    if let Ok(matrix_uri) = RumaMatrixUri::parse(&uri) {

        return Some(MatrixEntity {

            id: matrix_uri.id().into(),

            via: matrix_uri.via().iter().map(|via| via.to_string()).collect(),

        });

    }

    if let Ok(matrix_to_uri) = MatrixToUri::parse(&uri) {

        return Some(MatrixEntity {

            id: matrix_to_uri.id().into(),

            via: matrix_to_uri.via().iter().map(|via| via.to_string()).collect(),

        });

    }

    None

}

/// A Matrix entity that can be a room, room alias, user, or event, and a list

/// of via servers.

#[derive(uniffi::Record)]

pub struct MatrixEntity {

    id: MatrixId,

    via: Vec<String>,

}

/// A Matrix ID that can be a room, room alias, user, or event.

#[derive(Clone, uniffi::Enum)]

pub enum MatrixId {

    Room { id: String },

    RoomAlias { alias: String },

    User { id: String },

    EventOnRoomId { room_id: String, event_id: String },

    EventOnRoomAlias { alias: String, event_id: String },

}

impl From<&RumaMatrixId> for MatrixId {

    fn from(value: &RumaMatrixId) -> Self {

        match value {

            RumaMatrixId::User(id) => MatrixId::User { id: id.to_string() },

            RumaMatrixId::Room(id) => MatrixId::Room { id: id.to_string() },

            RumaMatrixId::RoomAlias(id) => MatrixId::RoomAlias { alias: id.to_string() },

            RumaMatrixId::Event(room_id_or_alias, event_id) => {

                if room_id_or_alias.is_room_id() {

                    MatrixId::EventOnRoomId {

                        room_id: room_id_or_alias.to_string(),

                        event_id: event_id.to_string(),

                    }

                } else if room_id_or_alias.is_room_alias_id() {

                    MatrixId::EventOnRoomAlias {

                        alias: room_id_or_alias.to_string(),

                        event_id: event_id.to_string(),

                    }

                } else {

                    panic!("Unexpected MatrixId type: {room_id_or_alias:?}")

                }

            }

            _ => panic!("Unexpected MatrixId type: {value:?}"),

        }

    }

}

#[matrix_sdk_ffi_macros::export]

pub fn message_event_content_new(

    msgtype: MessageType,

) -> Result<Arc<RoomMessageEventContentWithoutRelation>, ClientError> {

    Ok(Arc::new(RoomMessageEventContentWithoutRelation::new(msgtype.try_into()?)))

}

#[matrix_sdk_ffi_macros::export]

pub fn message_event_content_from_markdown(

    md: String,

) -> Arc<RoomMessageEventContentWithoutRelation> {

    Arc::new(RoomMessageEventContentWithoutRelation::new(RumaMessageType::text_markdown(md)))

}

#[matrix_sdk_ffi_macros::export]

pub fn message_event_content_from_markdown_as_emote(

    md: String,

) -> Arc<RoomMessageEventContentWithoutRelation> {

    Arc::new(RoomMessageEventContentWithoutRelation::new(RumaMessageType::emote_markdown(md)))

}

#[matrix_sdk_ffi_macros::export]

pub fn message_event_content_from_html(

    body: String,

    html_body: String,

) -> Arc<RoomMessageEventContentWithoutRelation> {

    Arc::new(RoomMessageEventContentWithoutRelation::new(RumaMessageType::text_html(

        body, html_body,

    )))

}

#[matrix_sdk_ffi_macros::export]

pub fn message_event_content_from_html_as_emote(

    body: String,

    html_body: String,

) -> Arc<RoomMessageEventContentWithoutRelation> {

    Arc::new(RoomMessageEventContentWithoutRelation::new(RumaMessageType::emote_html(

        body, html_body,

    )))

}

#[derive(Clone, uniffi::Object)]

pub struct MediaSource {

    pub(crate) media_source: RumaMediaSource,

}

#[matrix_sdk_ffi_macros::export]

impl MediaSource {

    #[uniffi::constructor]

    pub fn from_url(url: String) -> Result<Arc<MediaSource>, ClientError> {

        let media_source = RumaMediaSource::Plain(url.into());

        media_source.verify()?;

        Ok(Arc::new(MediaSource { media_source }))

    }

    pub fn url(&self) -> String {

        self.media_source.url()

    }

    // Used on Element X Android

    #[uniffi::constructor]

    pub fn from_json(json: String) -> Result<Arc<Self>, ClientError> {

        let media_source: RumaMediaSource = serde_json::from_str(&json)?;

        media_source.verify()?;

        Ok(Arc::new(MediaSource { media_source }))

    }

    // Used on Element X Android

    pub fn to_json(&self) -> String {

        serde_json::to_string(&self.media_source)

            .expect("Media source should always be serializable ")

    }

}

impl TryFrom<RumaMediaSource> for MediaSource {

    type Error = ClientError;

    fn try_from(value: RumaMediaSource) -> Result<Self, Self::Error> {

        value.verify()?;

        Ok(Self { media_source: value })

    }

}

impl TryFrom<&RumaMediaSource> for MediaSource {

    type Error = ClientError;

    fn try_from(value: &RumaMediaSource) -> Result<Self, Self::Error> {

        value.verify()?;

        Ok(Self { media_source: value.clone() })

    }

}

impl From<MediaSource> for RumaMediaSource {

    fn from(value: MediaSource) -> Self {

        value.media_source

    }

}

#[extension_trait]

pub(crate) impl MediaSourceExt for RumaMediaSource {

    fn verify(&self) -> Result<(), ClientError> {

        match self {

            RumaMediaSource::Plain(url) => {

                url.validate().map_err(ClientError::from_err)?;

            }

            RumaMediaSource::Encrypted(file) => {

                file.url.validate().map_err(ClientError::from_err)?;

            }

        }

        Ok(())

    }

    fn url(&self) -> String {

        match self {

            RumaMediaSource::Plain(url) => url.to_string(),

            RumaMediaSource::Encrypted(file) => file.url.to_string(),

        }

    }

}

#[extension_trait]

pub impl RoomMessageEventContentWithoutRelationExt for RoomMessageEventContentWithoutRelation {

    fn with_mentions(self: Arc<Self>, mentions: Mentions) -> Arc<Self> {

        let mut content = unwrap_or_clone_arc(self);

        content.mentions = Some(mentions.into());

        Arc::new(content)

    }

}

#[derive(Clone)]

pub struct Mentions {

    pub user_ids: Vec<String>,

    pub room: bool,

}

impl From<Mentions> for ruma::events::Mentions {

    fn from(value: Mentions) -> Self {

        let mut user_ids = BTreeSet::<OwnedUserId>::new();

        for user_id in value.user_ids {

            if let Ok(user_id) = UserId::parse(user_id) {

                user_ids.insert(user_id);

            }

        }

        let mut result = Self::default();

        result.user_ids = user_ids;

        result.room = value.room;

        result

    }

}

#[derive(Clone, uniffi::Enum)]

pub enum MessageType {

    Emote {

        content: EmoteMessageContent,

    },

    Image {

        content: ImageMessageContent,

    },

    Audio {

        content: AudioMessageContent,

    },

    Video {

        content: VideoMessageContent,

    },

    File {

        content: FileMessageContent,

    },

    #[cfg(feature = "unstable-msc4274")]

    Gallery {

        content: GalleryMessageContent,

    },

    Notice {

        content: NoticeMessageContent,

    },

    Text {

        content: TextMessageContent,

    },

    Location {

        content: LocationContent,

    },

    Other {

        msgtype: String,

        body: String,

    },

}

/// From MSC2530: https://github.com/matrix-org/matrix-spec-proposals/blob/main/proposals/2530-body-as-caption.md

/// If the filename field is present in a media message, clients should treat

/// body as a caption instead of a file name. Otherwise, the body is the

/// file name.

///

/// So:

/// - if a media has a filename and a caption, the body is the caption, filename

///   is its own field.

/// - if a media only has a filename, then body is the filename.

fn get_body_and_filename(filename: String, caption: Option<String>) -> (String, Option<String>) {

    if let Some(caption) = caption { (caption, Some(filename)) } else { (filename, None) }

}

impl TryFrom<MessageType> for RumaMessageType {

    type Error = ClientError;

    fn try_from(value: MessageType) -> Result<Self, Self::Error> {

        Ok(match value {

            MessageType::Emote { content } => {

                Self::Emote(assign!(RumaEmoteMessageEventContent::plain(content.body), {

                    formatted: content.formatted.map(Into::into),

                }))

            }

            MessageType::Image { content } => Self::Image(content.into()),

            MessageType::Audio { content } => Self::Audio(content.into()),

            MessageType::Video { content } => Self::Video(content.into()),

            MessageType::File { content } => Self::File(content.into()),

            #[cfg(feature = "unstable-msc4274")]

            MessageType::Gallery { content } => Self::Gallery(content.try_into()?),

            MessageType::Notice { content } => {

                Self::Notice(assign!(RumaNoticeMessageEventContent::plain(content.body), {

                    formatted: content.formatted.map(Into::into),

                }))

            }

            MessageType::Text { content } => {

                Self::Text(assign!(RumaTextMessageEventContent::plain(content.body), {

                    formatted: content.formatted.map(Into::into),

                }))

            }

            MessageType::Location { content } => {

                Self::Location(RumaLocationMessageEventContent::new(content.body, content.geo_uri))

            }

            MessageType::Other { msgtype, body } => {

                Self::new(&msgtype, body, JsonObject::default())?

            }

        })

    }

}

impl TryFrom<RumaMessageType> for MessageType {

    type Error = ClientError;

    fn try_from(value: RumaMessageType) -> Result<Self, Self::Error> {

        Ok(match value {

            RumaMessageType::Emote(c) => MessageType::Emote {

                content: EmoteMessageContent {

                    body: c.body.clone(),

                    formatted: c.formatted.as_ref().map(Into::into),

                },

            },

            RumaMessageType::Image(c) => MessageType::Image { content: c.try_into()? },

            RumaMessageType::Audio(c) => MessageType::Audio { content: c.try_into()? },

            RumaMessageType::Video(c) => MessageType::Video { content: c.try_into()? },

            RumaMessageType::File(c) => MessageType::File { content: c.try_into()? },

            #[cfg(feature = "unstable-msc4274")]

            RumaMessageType::Gallery(c) => MessageType::Gallery { content: c.try_into()? },

            RumaMessageType::Notice(c) => MessageType::Notice {

                content: NoticeMessageContent {

                    body: c.body.clone(),

                    formatted: c.formatted.as_ref().map(Into::into),

                },

            },

            RumaMessageType::Text(c) => MessageType::Text {

                content: TextMessageContent {

                    body: c.body.clone(),

                    formatted: c.formatted.as_ref().map(Into::into),

                },

            },

            RumaMessageType::Location(c) => {

                let (description, zoom_level) =

                    c.location.map(|loc| (loc.description, loc.zoom_level)).unwrap_or((None, None));

                MessageType::Location {

                    content: LocationContent {

                        body: c.body,

                        geo_uri: c.geo_uri,

                        description,

                        zoom_level: zoom_level.and_then(|z| z.get().try_into().ok()),

                        asset: c.asset.map(|a| a.type_).into(),

                    },

                }

            }

            _ => MessageType::Other {

                msgtype: value.msgtype().to_owned(),

                body: value.body().to_owned(),

            },

        })

    }

}

#[derive(Clone, uniffi::Enum)]

pub enum RtcNotificationType {

    Ring,

    Notification,