matrix-rust-sdk

use std::sync::Arc;

use futures_util::{Stream, StreamExt};

use matrix_sdk_common::executor::Handle;

use matrix_sdk_crypto::{

    CancelInfo as RustCancelInfo, QrVerification as InnerQr, QrVerificationState, Sas as InnerSas,

    SasState as RustSasState, Verification as InnerVerification,

    VerificationRequest as InnerVerificationRequest,

    VerificationRequestState as RustVerificationRequestState,

    matrix_sdk_qrcode::QrVerificationData,

};

use ruma::events::key::verification::VerificationMethod;

use vodozemac::{base64_decode, base64_encode};

use crate::{CryptoStoreError, OutgoingVerificationRequest, SignatureUploadRequest};

/// Listener that will be passed over the FFI to report changes to a SAS

/// verification.

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait SasListener: Send {

    /// The callback that should be called on the Rust side

    ///

    /// # Arguments

    ///

    /// * `state` - The current state of the SAS verification.

    fn on_change(&self, state: SasState);

}

/// An Enum describing the state the SAS verification is in.

#[derive(uniffi::Enum)]

pub enum SasState {

    /// The verification has been created, the protocols that should be used

    /// have been proposed to the other party.

    Created,

    /// The verification has been started, the other party proposed the

    /// protocols that should be used and that can be accepted.

    Started,

    /// The verification has been accepted and both sides agreed to a set of

    /// protocols that will be used for the verification process.

    Accepted,

    /// The public keys have been exchanged and the short auth string can be

    /// presented to the user.

    KeysExchanged {

        /// The emojis that represent the short auth string, will be `None` if

        /// the emoji SAS method wasn't one of accepted protocols.

        emojis: Option<Vec<i32>>,

        /// The list of decimals that represent the short auth string.

        decimals: Vec<i32>,

    },

    /// The verification process has been confirmed from our side, we're waiting

    /// for the other side to confirm as well.

    Confirmed,

    /// The verification process has been successfully concluded.

    Done,

    /// The verification process has been cancelled.

    Cancelled {

        /// Information about the reason of the cancellation.

        cancel_info: CancelInfo,

    },

}

impl From<RustSasState> for SasState {

    fn from(s: RustSasState) -> Self {

        match s {

            RustSasState::Created { .. } => Self::Created,

            RustSasState::Started { .. } => Self::Started,

            RustSasState::Accepted { .. } => Self::Accepted,

            RustSasState::KeysExchanged { emojis, decimals } => Self::KeysExchanged {

                emojis: emojis.map(|e| e.indices.map(|i| i as i32).to_vec()),

                decimals: [decimals.0.into(), decimals.1.into(), decimals.2.into()].to_vec(),

            },

            RustSasState::Confirmed => Self::Confirmed,

            RustSasState::Done { .. } => Self::Done,

            RustSasState::Cancelled(c) => Self::Cancelled { cancel_info: c.into() },

        }

    }

}

/// Enum representing the different verification flows we support.

#[derive(uniffi::Object)]

pub struct Verification {

    pub(crate) inner: InnerVerification,

    pub(crate) runtime: Handle,

}

#[matrix_sdk_ffi_macros::export]

impl Verification {

    /// Try to represent the `Verification` as an `Sas` verification object,

    /// returns `None` if the verification is not a `Sas` verification.

    pub fn as_sas(&self) -> Option<Arc<Sas>> {

        if let InnerVerification::SasV1(sas) = &self.inner {

            Some(Sas { inner: sas.clone(), runtime: self.runtime.to_owned() }.into())

        } else {

            None

        }

    }

    /// Try to represent the `Verification` as an `QrCode` verification object,

    /// returns `None` if the verification is not a `QrCode` verification.

    pub fn as_qr(&self) -> Option<Arc<QrCode>> {

        if let InnerVerification::QrV1(qr) = &self.inner {

            Some(QrCode { inner: qr.clone(), runtime: self.runtime.to_owned() }.into())

        } else {

            None

        }

    }

}

/// The `m.sas.v1` verification flow.

#[derive(uniffi::Object)]

pub struct Sas {

    pub(crate) inner: Box<InnerSas>,

    pub(crate) runtime: Handle,

}

#[matrix_sdk_ffi_macros::export]

impl Sas {

    /// Get the user id of the other side.

    pub fn other_user_id(&self) -> String {

        self.inner.other_user_id().to_string()

    }

    /// Get the device ID of the other side.

    pub fn other_device_id(&self) -> String {

        self.inner.other_device_id().to_string()

    }

    /// Get the unique ID that identifies this SAS verification flow.

    pub fn flow_id(&self) -> String {

        self.inner.flow_id().as_str().to_owned()

    }

    /// Get the room id if the verification is happening inside a room.

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

        self.inner.room_id().map(|r| r.to_string())

    }

    /// Is the SAS flow done.

    pub fn is_done(&self) -> bool {

        self.inner.is_done()

    }

    /// Did we initiate the verification flow.

    pub fn we_started(&self) -> bool {

        self.inner.we_started()

    }

    /// Accept that we're going forward with the short auth string verification.

    pub fn accept(&self) -> Option<OutgoingVerificationRequest> {

        self.inner.accept().map(|r| r.into())

    }

    /// Confirm a verification was successful.

    ///

    /// This method should be called if a short auth string should be confirmed

    /// as matching.

    pub fn confirm(&self) -> Result<Option<ConfirmVerificationResult>, CryptoStoreError> {

        let (requests, signature_request) = self.runtime.block_on(self.inner.confirm())?;

        let requests = requests.into_iter().map(|r| r.into()).collect();

        Ok(Some(ConfirmVerificationResult {

            requests,

            signature_request: signature_request.map(|s| s.into()),

        }))

    }

    /// Cancel the SAS verification using the given cancel code.

    ///

    /// # Arguments

    ///

    /// * `cancel_code` - The error code for why the verification was cancelled,

    ///   manual cancellatio usually happens with `m.user` cancel code. The full

    ///   list of cancel codes can be found in the [spec]

    ///

    /// [spec]: https://spec.matrix.org/unstable/client-server-api/#mkeyverificationcancel

    pub fn cancel(&self, cancel_code: String) -> Option<OutgoingVerificationRequest> {

        self.inner.cancel_with_code(cancel_code.into()).map(|r| r.into())

    }

    /// Get a list of emoji indices of the emoji representation of the short

    /// auth string.

    ///

    /// *Note*: A SAS verification needs to be started and in the presentable

    /// state for this to return the list of emoji indices, otherwise returns

    /// `None`.

    pub fn get_emoji_indices(&self) -> Option<Vec<i32>> {

        self.inner.emoji_index().map(|v| v.iter().map(|i| (*i).into()).collect())

    }

    /// Get the decimal representation of the short auth string.

    ///

    /// *Note*: A SAS verification needs to be started and in the presentable

    /// state for this to return the list of decimals, otherwise returns

    /// `None`.

    pub fn get_decimals(&self) -> Option<Vec<i32>> {

        self.inner.decimals().map(|v| [v.0.into(), v.1.into(), v.2.into()].to_vec())

    }

    /// Set a listener for changes in the SAS verification process.

    ///

    /// The given callback will be called whenever the state changes.

    ///

    /// This method can be used to react to changes in the state of the

    /// verification process, or rather the method can be used to handle

    /// each step of the verification process.

    ///

    /// This method will spawn a tokio task on the Rust side, once we reach the

    /// Done or Cancelled state, the task will stop listening for changes.

    ///

    /// # Flowchart

    ///

    /// The flow of the verification process is pictured below. Please note

    /// that the process can be cancelled at each step of the process.

    /// Either side can cancel the process.

    ///

    /// ```text

    ///                ┌───────┐

    ///                │Started│

    ///                └───┬───┘

    ///                    │

    ///               ┌────⌄───┐

    ///               │Accepted│

    ///               └────┬───┘

    ///                    │

    ///            ┌───────⌄──────┐

    ///            │Keys Exchanged│

    ///            └───────┬──────┘

    ///                    │

    ///            ________⌄________

    ///           ╱                 ╲       ┌─────────┐

    ///          ╱   Does the short  ╲______│Cancelled│

    ///          ╲ auth string match ╱ no   └─────────┘

    ///           ╲_________________╱

    ///                    │yes

    ///                    │

    ///               ┌────⌄────┐

    ///               │Confirmed│

    ///               └────┬────┘

    ///                    │

    ///                ┌───⌄───┐

    ///                │  Done │

    ///                └───────┘

    /// ```

    pub fn set_changes_listener(&self, listener: Box<dyn SasListener>) {

        let stream = self.inner.changes();

        self.runtime.spawn(Self::changes_listener(stream, listener));

    }

    /// Get the current state of the SAS verification process.

    pub fn state(&self) -> SasState {

        self.inner.state().into()

    }

}

impl Sas {

    async fn changes_listener(

        mut stream: impl Stream<Item = RustSasState> + std::marker::Unpin,

        listener: Box<dyn SasListener>,

    ) {

        while let Some(state) = stream.next().await {

            // If we receive a done or a cancelled state we're at the end of our road, we

            // break out of the loop to deallocate the stream and finish the

            // task.

            let should_break =

                matches!(state, RustSasState::Done { .. } | RustSasState::Cancelled { .. });

            listener.on_change(state.into());

            if should_break {

                break;

            }

        }

    }

}

/// Listener that will be passed over the FFI to report changes to a QrCode

/// verification.

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait QrCodeListener: Send {

    /// The callback that should be called on the Rust side

    ///

    /// # Arguments

    ///

    /// * `state` - The current state of the QrCode verification.

    fn on_change(&self, state: QrCodeState);

}

/// An Enum describing the state the QrCode verification is in.

#[derive(uniffi::Enum)]

pub enum QrCodeState {

    /// The QR verification has been started.

    Started,

    /// The QR verification has been scanned by the other side.

    Scanned,

    /// The scanning of the QR code has been confirmed by us.

    Confirmed,

    /// We have successfully scanned the QR code and are able to send a

    /// reciprocation event.

    Reciprocated,

    /// The verification process has been successfully concluded.

    Done,

    /// The verification process has been cancelled.

    Cancelled {

        /// Information about the reason of the cancellation.

        cancel_info: CancelInfo,

    },

}

impl From<QrVerificationState> for QrCodeState {

    fn from(value: QrVerificationState) -> Self {

        match value {

            QrVerificationState::Started => Self::Started,

            QrVerificationState::Scanned => Self::Scanned,

            QrVerificationState::Confirmed => Self::Confirmed,

            QrVerificationState::Reciprocated => Self::Reciprocated,

            QrVerificationState::Done { .. } => Self::Done,

            QrVerificationState::Cancelled(c) => Self::Cancelled { cancel_info: c.into() },

        }

    }

}

/// The `m.qr_code.scan.v1`, `m.qr_code.show.v1`, and `m.reciprocate.v1`

/// verification flow.

#[derive(uniffi::Object)]

pub struct QrCode {

    pub(crate) inner: Box<InnerQr>,

    pub(crate) runtime: Handle,

}

#[matrix_sdk_ffi_macros::export]

impl QrCode {

    /// Get the user id of the other side.

    pub fn other_user_id(&self) -> String {

        self.inner.other_user_id().to_string()

    }

    /// Get the device ID of the other side.

    pub fn other_device_id(&self) -> String {

        self.inner.other_device_id().to_string()

    }

    /// Get the unique ID that identifies this QR code verification flow.

    pub fn flow_id(&self) -> String {

        self.inner.flow_id().as_str().to_owned()

    }

    /// Get the room id if the verification is happening inside a room.

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

        self.inner.room_id().map(|r| r.to_string())

    }

    /// Is the QR code verification done.

    pub fn is_done(&self) -> bool {

        self.inner.is_done()

    }

    /// Has the verification flow been cancelled.

    pub fn is_cancelled(&self) -> bool {

        self.inner.is_cancelled()

    }

    /// Did we initiate the verification flow.

    pub fn we_started(&self) -> bool {

        self.inner.we_started()

    }

    /// Get the CancelInfo of this QR code verification object.

    ///

    /// Will be `None` if the flow has not been cancelled.

    pub fn cancel_info(&self) -> Option<CancelInfo> {

        self.inner.cancel_info().map(|c| c.into())

    }

    /// Has the QR verification been scanned by the other side.

    ///

    /// When the verification object is in this state it's required that the

    /// user confirms that the other side has scanned the QR code.

    pub fn has_been_scanned(&self) -> bool {

        self.inner.has_been_scanned()

    }

    /// Have we successfully scanned the QR code and are able to send a

    /// reciprocation event.

    pub fn reciprocated(&self) -> bool {

        self.inner.reciprocated()

    }

    /// Cancel the QR code verification using the given cancel code.

    ///

    /// # Arguments

    ///

    /// * `cancel_code` - The error code for why the verification was cancelled,

    ///   manual cancellatio usually happens with `m.user` cancel code. The full

    ///   list of cancel codes can be found in the [spec]

    ///

    /// [spec]: https://spec.matrix.org/unstable/client-server-api/#mkeyverificationcancel

    pub fn cancel(&self, cancel_code: String) -> Option<OutgoingVerificationRequest> {

        self.inner.cancel_with_code(cancel_code.into()).map(|r| r.into())

    }

    /// Confirm a verification was successful.

    ///

    /// This method should be called if we want to confirm that the other side

    /// has scanned our QR code.

    pub fn confirm(&self) -> Option<ConfirmVerificationResult> {

        self.inner.confirm_scanning().map(|r| ConfirmVerificationResult {

            requests: vec![r.into()],

            signature_request: None,

        })

    }

    /// Generate data that should be encoded as a QR code.

    ///

    /// This method should be called right before a QR code should be displayed,

    /// the returned data is base64 encoded (without padding) and needs to be

    /// decoded on the other side before it can be put through a QR code

    /// generator.

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

        self.inner.to_bytes().map(base64_encode).ok()

    }

    /// Set a listener for changes in the QrCode verification process.

    ///

    /// The given callback will be called whenever the state changes.

    pub fn set_changes_listener(&self, listener: Box<dyn QrCodeListener>) {

        let stream = self.inner.changes();

        self.runtime.spawn(Self::changes_listener(stream, listener));

    }

    /// Get the current state of the QrCode verification process.

    pub fn state(&self) -> QrCodeState {

        self.inner.state().into()

    }

}

impl QrCode {

    async fn changes_listener(

        mut stream: impl Stream<Item = QrVerificationState> + std::marker::Unpin,

        listener: Box<dyn QrCodeListener>,

    ) {

        while let Some(state) = stream.next().await {

            // If we receive a done or a cancelled state we're at the end of our road, we

            // break out of the loop to deallocate the stream and finish the

            // task.

            let should_break = matches!(

                state,

                QrVerificationState::Done { .. } | QrVerificationState::Cancelled { .. }

            );

            listener.on_change(state.into());

            if should_break {

                break;

            }

        }

    }

}

/// Information on why a verification flow has been cancelled and by whom.

#[derive(uniffi::Record)]

pub struct CancelInfo {

    /// The textual representation of the cancel reason

    pub reason: String,

    /// The code describing the cancel reason

    pub cancel_code: String,

    /// Was the verification flow cancelled by us

    pub cancelled_by_us: bool,

}

impl From<RustCancelInfo> for CancelInfo {

    fn from(c: RustCancelInfo) -> Self {

        Self {

            reason: c.reason().to_owned(),

            cancel_code: c.cancel_code().to_string(),

            cancelled_by_us: c.cancelled_by_us(),

        }

    }

}

/// A result type for starting SAS verifications.

#[derive(uniffi::Record)]

pub struct StartSasResult {

    /// The SAS verification object that got created.

    pub sas: Arc<Sas>,

    /// The request that needs to be sent out to notify the other side that a

    /// SAS verification should start.

    pub request: OutgoingVerificationRequest,

}

/// A result type for scanning QR codes.

#[derive(uniffi::Record)]

pub struct ScanResult {

    /// The QR code verification object that got created.

    pub qr: Arc<QrCode>,

    /// The request that needs to be sent out to notify the other side that a

    /// QR code verification should start.

    pub request: OutgoingVerificationRequest,

}

/// A result type for requesting verifications.

#[derive(uniffi::Record)]

pub struct RequestVerificationResult {

    /// The verification request object that got created.

    pub verification: Arc<VerificationRequest>,

    /// The request that needs to be sent out to notify the other side that

    /// we're requesting verification to begin.

    pub request: OutgoingVerificationRequest,

}

/// A result type for confirming verifications.

#[derive(uniffi::Record)]