macltok

use std::sync::Arc;

use matrix_sdk::{

    HttpError, RefreshTokenError,

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

    #[source]

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

    source: Option<Arc<dyn std::error::Error + Send + Sync>>,

}

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

}

impl Error {

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

        Self {

            kind,

            message: message.into(),

            challenge: None,

            source: None,

        }

    }

    pub(crate) fn with_source(

        kind: ErrorKind,

        message: impl Into<String>,

        source: impl std::error::Error + Send + Sync + 'static,

    ) -> Self {

        Self {

            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

    }

}

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,

    }

}