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))]

pub enum ErrorKind {

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

    Interrupted,

    Unauthenticated,

    InteractiveAuthRequired,

    Invalid,

    /// the room's power levels don't let you

    Forbidden,

    RoomUnknown,

    RoomNotOpen,

    TimelineNotOpen,

    EventContextNotOpen,

    SearchNotOpen,

    EventNotFound,

    RoomBusy,

    QueueFull,

    EmptyBody,

    MediaUnknown,

    MediaTooLarge,

    MediaUnavailable,

    VerificationInactive,

    VerificationUnsupported,

    NoCrossSigningIdentity,

    RecoveryRejected,

    /// the server already holds a key backup, which recovery has to open or replace first

    KeyBackupExists,

    Network,

    /// the homeserver wants us to slow down. try again later

    RateLimited,

    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 => ErrorKind::KeyBackupExists,

            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(_)

            if source

                .as_client_api_error()

                .is_some_and(|api| api.status_code.as_u16() == 429) =>

        {

            ErrorKind::RateLimited

        }

        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,

    }

}