macltok

use std::sync::Arc;

use matrix_sdk::{

    HttpError, RefreshTokenError, SendOutsideWasm, SyncOutsideWasm,

    authentication::oauth::error::{

        OAuthAuthorizationCodeError, OAuthDiscoveryError, OAuthError, OAuthTokenRevocationError,

        RequestTokenError,

    },

    encryption::{

        identities::{ManualVerifyError, RequestVerificationError},

        recovery::RecoveryError,

        secret_storage::{ImportError, SecretStorageError},

    },

};

#[cfg(feature = "serde")]

use serde::{Deserialize, Serialize};

use crate::InteractiveAuthChallenge;

/// the sdk's `SendOutsideWasm` isn't an auto trait, so it can't go in a trait object

#[cfg(not(target_family = "wasm"))]

pub(crate) type SourceError = dyn std::error::Error + Send + Sync;

#[cfg(target_family = "wasm")]

pub(crate) type SourceError = dyn std::error::Error;

/// the one thing that goes wrong, for commands and queries alike. match on `kind`, show `message`

#[derive(Clone, Debug, thiserror::Error)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[error("{message}")]

#[non_exhaustive]

pub struct Error {

    pub kind: ErrorKind,

    pub message: String,

    /// set when the server wants interactive auth before it'll do the thing

    pub challenge: Option<Box<InteractiveAuthChallenge>>,

    /// set when the homeserver refused with a matrix error

    pub server: Option<ServerError>,

    #[source]

    #[cfg_attr(feature = "serde", serde(skip))]

    source: Option<Arc<SourceError>>,

}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[non_exhaustive]

pub enum ErrorKind {

    /// the engine stopped, or the task doing the work died, before answering

    Interrupted,

    Unauthenticated,

    InteractiveAuthRequired,

    Invalid,

    RoomUnknown,

    RoomNotOpen,

    TimelineNotOpen,

    RoomBusy,

    QueueFull,

    EmptyBody,

    MediaUnknown,

    MediaTooLarge,

    MediaUnavailable,

    VerificationInactive,

    VerificationUnsupported,

    NoCrossSigningIdentity,

    RecoveryRejected,

    Network,

    Server,

    Store,

    Timeline,

    Encryption,

    Other,

}

/// the homeserver's own answer, worth showing a person as it stands

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[non_exhaustive]

pub struct ServerError {

    pub status: u16,

    pub errcode: String,

    pub message: String,

}

impl ServerError {

    pub(crate) fn find(source: &(dyn std::error::Error + 'static)) -> Option<Self> {

        let mut current = Some(source);

        while let Some(error) = current {

            let api = if let Some(error) = error.downcast_ref::<matrix_sdk::Error>() {

                error.as_client_api_error()

            } else if let Some(error) = error.downcast_ref::<HttpError>() {

                error.as_client_api_error()

            } else {

                error.downcast_ref::<ruma::api::error::Error>()

            };

            if let Some(api) = api

                && let ruma::api::error::ErrorBody::Standard(body) = &api.body

            {

                return Some(Self {

                    status: api.status_code.as_u16(),

                    errcode: body.kind.errcode().to_string(),

                    message: body.message.clone(),

                });

            }

            current = error.source();

        }

        None

    }

}

impl std::fmt::Display for ServerError {

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

        write!(formatter, "{} ({})", self.message, self.errcode)

    }

}

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

pub(crate) fn classify(source: &(dyn std::error::Error + 'static)) -> ErrorKind {

    let mut current = Some(source);

    while let Some(error) = current {

        if let Some(error) = error.downcast_ref::<matrix_sdk::Error>() {

            return classify_sdk_error(error);

        }

        if let Some(error) = error.downcast_ref::<HttpError>() {

            return classify_http_error(error);

        }

        if let Some(error) = error.downcast_ref::<OAuthError>() {

            return classify_oauth_error(error);

        }

        if let Some(error) = error.downcast_ref::<RefreshTokenError>() {

            return classify_refresh_token_error(error);

        }

        current = error.source();

    }

    ErrorKind::Other

}

impl Error {

    pub(crate) fn new(kind: ErrorKind, message: impl Into<String>) -> Self {

        Self {

            kind,

            message: message.into(),

            challenge: None,

            server: None,

            source: None,

        }

    }

    pub(crate) fn with_source(

        kind: ErrorKind,

        message: impl Into<String>,

        source: impl std::error::Error + SendOutsideWasm + SyncOutsideWasm + 'static,

    ) -> Self {

        Self {

            server: ServerError::find(&source),

            source: Some(Arc::new(source)),

            ..Self::new(kind, message)

        }

    }

    pub(crate) fn interrupted() -> Self {

        Self::new(

            ErrorKind::Interrupted,

            "the engine stopped before the operation finished",

        )

    }

    pub(crate) fn room_unknown() -> Self {

        Self::new(

            ErrorKind::RoomUnknown,

            "room is not available in the local store",

        )

    }

    pub(crate) fn interactive_auth(challenge: InteractiveAuthChallenge) -> Self {

        Self {

            challenge: Some(Box::new(challenge)),

            ..Self::new(

                ErrorKind::InteractiveAuthRequired,

                "interactive authentication is required",

            )

        }

    }

    pub(crate) fn from_sdk(message: impl Into<String>, source: matrix_sdk::Error) -> Self {

        Self::with_source(classify_sdk_error(&source), message, source)

    }

    pub(crate) fn from_http(message: impl Into<String>, source: HttpError) -> Self {

        Self::with_source(classify_http_error(&source), message, source)

    }

    pub(crate) fn from_refresh_token(

        message: impl Into<String>,

        source: RefreshTokenError,

    ) -> Self {

        Self::with_source(classify_refresh_token_error(&source), message, source)

    }

    pub(crate) fn from_recovery(message: impl Into<String>, source: RecoveryError) -> Self {

        let kind = match &source {

            RecoveryError::Sdk(source) => classify_sdk_error(source),

            RecoveryError::SecretStorage(SecretStorageError::Sdk(source)) => {

                classify_sdk_error(source)

            }

            RecoveryError::SecretStorage(SecretStorageError::ImportError { error, .. }) => {

                match error {

                    ImportError::Sdk(source) => classify_sdk_error(source),

                    _ => ErrorKind::RecoveryRejected,

                }

            }

            RecoveryError::SecretStorage(SecretStorageError::Verification(source)) => {

                match source {

                    ManualVerifyError::Http(source) => classify_http_error(source),

                    _ => ErrorKind::RecoveryRejected,

                }

            }

            RecoveryError::SecretStorage(SecretStorageError::SecretStorageKey(_)) => {

                ErrorKind::RecoveryRejected

            }

            RecoveryError::SecretStorage(SecretStorageError::Storage(_)) => ErrorKind::Store,

            RecoveryError::BackupExistsOnServer | RecoveryError::SecretStorage(_) => {

                ErrorKind::RecoveryRejected

            }

        };

        Self::with_source(kind, message, source)

    }

    pub(crate) fn from_verification_request(

        message: impl Into<String>,

        source: RequestVerificationError,

    ) -> Self {

        let kind = match &source {

            RequestVerificationError::Sdk(source) => classify_sdk_error(source),

            RequestVerificationError::RoomCreation(_) => ErrorKind::Encryption,

        };

        Self::with_source(kind, message, source)

    }

}

impl PartialEq for Error {

    fn eq(&self, other: &Self) -> bool {

        self.kind == other.kind

            && self.message == other.message

            && self.challenge == other.challenge

            && self.server == other.server

    }

}

pub(crate) fn classify_sdk_error(source: &matrix_sdk::Error) -> ErrorKind {

    match source {

        matrix_sdk::Error::Http(source) => classify_http_error(source),

        matrix_sdk::Error::OAuth(source) => classify_oauth_error(source),

        matrix_sdk::Error::AuthenticationRequired => ErrorKind::Unauthenticated,

        matrix_sdk::Error::BadCryptoStoreState

        | matrix_sdk::Error::CryptoStoreError(_)

        | matrix_sdk::Error::CrossProcessLockError(_)

        | matrix_sdk::Error::StateStore(_)

        | matrix_sdk::Error::EventCacheStore(_)

        | matrix_sdk::Error::MediaStore(_) => ErrorKind::Store,

        matrix_sdk::Error::NoOlmMachine

        | matrix_sdk::Error::OlmError(_)

        | matrix_sdk::Error::MegolmError(_)

        | matrix_sdk::Error::DecryptorError(_) => ErrorKind::Encryption,

        matrix_sdk::Error::Media(_) => ErrorKind::MediaUnavailable,

        matrix_sdk::Error::Timeout => ErrorKind::Network,

        _ => ErrorKind::Other,

    }

}

fn classify_http_error(source: &HttpError) -> ErrorKind {

    match source {

        HttpError::Reqwest(_) => ErrorKind::Network,

        HttpError::Api(_) => ErrorKind::Server,

        HttpError::RefreshToken(source) => classify_refresh_token_error(source),

        HttpError::Cached(source) => classify_http_error(source),

        _ => ErrorKind::Other,

    }

}

fn classify_refresh_token_error(source: &RefreshTokenError) -> ErrorKind {

    match source {

        RefreshTokenError::RefreshTokenRequired => ErrorKind::Unauthenticated,

        RefreshTokenError::MatrixAuth(source) => classify_http_error(source),

        RefreshTokenError::OAuth(source) => classify_oauth_error(source),

    }

}

fn classify_oauth_error(source: &OAuthError) -> ErrorKind {

    let classify_token_request_error = |source: &_| match source {

        RequestTokenError::Request(_) => ErrorKind::Network,

        RequestTokenError::ServerResponse(_) => ErrorKind::Unauthenticated,

        _ => ErrorKind::Other,

    };

    match source {

        OAuthError::Discovery(source) => match source {

            OAuthDiscoveryError::Http(source) => classify_http_error(source),

            OAuthDiscoveryError::Oidc(source) => classify_token_request_error(source),

            _ => ErrorKind::Unauthenticated,

        },

        OAuthError::RefreshToken(source) => classify_token_request_error(source),

        OAuthError::AuthorizationCode(OAuthAuthorizationCodeError::RequestToken(source)) => {

            classify_token_request_error(source)

        }

        OAuthError::AuthorizationCode(_) => ErrorKind::Unauthenticated,

        OAuthError::Logout(source) => match source {

            OAuthTokenRevocationError::Revoke(RequestTokenError::Request(_)) => ErrorKind::Network,

            OAuthTokenRevocationError::Revoke(RequestTokenError::ServerResponse(_)) => {

                ErrorKind::Unauthenticated

            }

            _ => ErrorKind::Other,

        },

        _ => ErrorKind::Unauthenticated,

    }

}