use std::fmt;

use sea_orm::DbErr;

#[derive(Debug)]
pub enum ExportError {
    Database(DbErr),
    Redis(redis::RedisError),
    Storage(storage::StorageError),
    InvalidConfig(String),
    Connection(String),
    Unsupported(String),
}

impl fmt::Display for ExportError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ExportError::Database(err) => write!(f, "database error: {err}"),
            ExportError::Redis(err) => write!(f, "redis error: {err}"),
            ExportError::Storage(err) => write!(f, "storage error: {err}"),
            ExportError::InvalidConfig(msg) => write!(f, "invalid config: {msg}"),
            ExportError::Connection(msg) => write!(f, "connection error: {msg}"),
            ExportError::Unsupported(msg) => write!(f, "unsupported operation: {msg}"),
        }
    }
}

impl std::error::Error for ExportError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            ExportError::Database(err) => Some(err),
            ExportError::Redis(err) => Some(err),
            ExportError::Storage(err) => Some(err),
            _ => None,
        }
    }
}

impl From<DbErr> for ExportError {
    fn from(err: DbErr) -> Self {
        ExportError::Database(err)
    }
}

impl From<redis::RedisError> for ExportError {
    fn from(err: redis::RedisError) -> Self {
        ExportError::Redis(err)
    }
}

impl From<storage::StorageError> for ExportError {
    fn from(err: storage::StorageError) -> Self {
        ExportError::Storage(err)
    }
}