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

#[derive(Debug)]
pub enum ErrorType {
    DBErr(DBError),
    IDErr(IDError),
    TableAddFieldDuplicate(String),
    TableRecordInvalidFieldName(String),
}

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 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::TableAddFieldDuplicate(data) => write!(f, "field '{}' already exists", data),
            ErrorType::TableRecordInvalidFieldName(data) => {
                write!(f, "invalid field name '{}'", 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));
    }
}

#[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<IDError> for MTTError {
    fn from(value: IDError) -> 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_duplicate_table_name() {
        let data = rand_str();
        let etype = ErrorType::TableAddFieldDuplicate(data.clone());
        let result = MTTError::from(etype);
        match result.get_code() {
            ErrorType::TableAddFieldDuplicate(txt) => assert_eq!(txt, &data),
            _ => unreachable!("should have been ErrorType::FieldIDInvalid"),
        }
        assert_eq!(
            result.to_string(),
            format!("field '{}' already exists", data)
        );
    }

    #[test]
    fn error_type_strings() {
        let data = rand_str();
        let etype = ErrorType::TableRecordInvalidFieldName(data.clone());
        assert_eq!(etype.to_string(), format!("invalid field name '{}'", data));
    }
}