use crate::data::{id::IDError, table::TBLError, DBError};
use std::{error::Error, fmt};

#[derive(Debug)]
pub enum ErrorType {
    DBErr(DBError),
    IDErr(IDError),
    TBLErr(TBLError),
}

impl From<DBError> for ErrorType {
    fn from(value: DBError) -> Self {
        ErrorType::DBErr(value)
    }
}

impl From<IDError> for ErrorType {
    fn from(value: IDError) -> Self {
        ErrorType::IDErr(value)
    }
}

impl From<TBLError> for ErrorType {
    fn from(value: TBLError) -> Self {
        ErrorType::TBLErr(value)
    }
}

impl fmt::Display for ErrorType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ErrorType::DBErr(data) => write!(f, "database: {}", data),
            ErrorType::IDErr(data) => write!(f, "id: {}", data),
            ErrorType::TBLErr(data) => write!(f, "table: {}", data),
        }
    }
}

#[cfg(test)]
mod errortypes {
    use super::*;

    #[test]
    fn database_error() {
        let err = DBError::DuplicateTable("something".to_string());
        let result = ErrorType::from(err.clone());
        assert_eq!(result.to_string(), format!("database: {}", err));
    }

    #[test]
    fn id_error() {
        let err = IDError::InvalidUuid("bad".to_string());
        let result = ErrorType::from(err.clone());
        assert_eq!(result.to_string(), format!("id: {}", err));
    }

    #[test]
    fn table_error() {
        let err = TBLError::InvalidField("bad".to_string());
        let result = ErrorType::from(err.clone());
        assert_eq!(result.to_string(), format!("table: {}", err));
    }
}

#[derive(Debug)]
pub struct MTTError {
    err: ErrorType,
}

impl From<ErrorType> for MTTError {
    fn from(value: ErrorType) -> Self {
        MTTError::new(value)
    }
}

impl MTTError {
    pub fn new(err: ErrorType) -> Self {
        Self { err: err }
    }

    pub fn get_code(&self) -> &ErrorType {
        &self.err
    }
}

impl Error for MTTError {}

impl fmt::Display for MTTError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.err.to_string())
    }
}

impl From<DBError> for MTTError {
    fn from(value: DBError) -> Self {
        Self { err: value.into() }
    }
}

impl From<IDError> for MTTError {
    fn from(value: IDError) -> Self {
        Self { err: value.into() }
    }
}

impl From<TBLError> for MTTError {
    fn from(value: TBLError) -> Self {
        Self { err: value.into() }
    }
}

#[cfg(test)]
mod errors {
    use super::*;
    use rand::{distributions::Alphanumeric, Rng};

    fn rand_str() -> String {
        rand::thread_rng()
            .sample_iter(&Alphanumeric)
            .take(5)
            .map(char::from)
            .collect()
    }

    #[test]
    fn from_id_error() {
        let error = IDError::InvalidUuid(rand_str());
        let err = MTTError::from(error.clone());
        assert_eq!(err.to_string(), ErrorType::IDErr(error).to_string());
    }

    #[test]
    fn from_database_error() {
        let error = DBError::DuplicateTable(rand_str());
        let err = MTTError::from(error.clone());
        assert_eq!(err.to_string(), ErrorType::DBErr(error).to_string());
    }

    #[test]
    fn from_table_error() {
        let error = TBLError::InvalidField(rand_str());
        let err = MTTError::from(error.clone());
        assert_eq!(err.to_string(), ErrorType::TBLErr(error).to_string());
    }
}