use sea_orm::DbErr;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum JwtError {
    #[error("authorization header missing")]
    MissingHeader,
    #[error("invalid authorization header")]
    InvalidHeader,
    #[error("invalid token encoding")]
    InvalidEncoding,
    #[error("invalid signature")]
    InvalidSignature,
    #[error("token expired")]
    Expired,
    #[error("token not yet valid")]
    NotYetValid,
    #[error("unknown key id: {0}")]
    UnknownKid(String),
    #[error("invalid audience")]
    InvalidAudience,
    #[error("invalid issuer")]
    InvalidIssuer,
    #[error("no active signing key available")]
    NoActiveKey,
    #[error("session revoked")]
    SessionRevoked,
    #[error("session replaced")]
    SessionReplaced,
    #[error("session not found")]
    SessionNotFound,
    #[error("database error: {0}")]
    Db(#[from] DbErr),
    #[error("base64 error: {0}")]
    Base64(#[from] base64::DecodeError),
    #[error("crypto error")]
    Crypto,
    #[error("config error: {0}")]
    Config(String),
    #[error("cancelled")]
    Cancelled,
    #[error("other error: {0}")]
    Other(String),
}

impl From<jsonwebtoken::errors::Error> for JwtError {
    fn from(e: jsonwebtoken::errors::Error) -> Self {
        use jsonwebtoken::errors::ErrorKind;
        match e.kind() {
            ErrorKind::ExpiredSignature => JwtError::Expired,
            ErrorKind::InvalidSignature => JwtError::InvalidSignature,
            ErrorKind::InvalidToken => JwtError::InvalidEncoding,
            ErrorKind::InvalidAudience => JwtError::InvalidAudience,
            ErrorKind::InvalidIssuer => JwtError::InvalidIssuer,
            ErrorKind::ImmatureSignature => JwtError::NotYetValid,
            _ => JwtError::Other(e.to_string()),
        }
    }
}

impl From<jsonwebtoken::errors::ErrorKind> for JwtError {
    fn from(kind: jsonwebtoken::errors::ErrorKind) -> Self {
        let e = jsonwebtoken::errors::Error::from(kind);
        e.into()
    }
}