use std::{error::Error, fmt};

#[derive(Debug)]
pub enum ErrorType {
    FieldIDInvalid(String),
    TableAddFieldDuplicate(String),
    TableRecordInvalidFieldName(String),
}

impl fmt::Display for ErrorType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ErrorType::FieldIDInvalid(data) => write!(f, "'{}' is not a valid uuid", data),
            ErrorType::TableAddFieldDuplicate(data) => write!(f, "field '{}' already exists", data),
            ErrorType::TableRecordInvalidFieldName(data) => {
                write!(f, "invalid field name '{}'", data)
            }
        }
    }
}

#[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())
    }
}

#[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_invalid_id() {
        let data = rand_str();
        let etype = ErrorType::FieldIDInvalid(data.clone());
        let result = MTTError::from(etype);
        match result.get_code() {
            ErrorType::FieldIDInvalid(txt) => assert_eq!(txt, &data),
            _ => unreachable!("should have been ErrorType::FieldIDInvalid"),
        }
        assert_eq!(
            result.to_string(),
            format!("'{}' is not a valid uuid", data)
        );
    }

    #[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));
    }
}