use crate::{
    document::field::{Field, FieldType},
    message::MessageAction,
    name::{Name, NameType},
};
use isolang::Language;
use std::{error::Error, fmt};
use uuid::Uuid;

#[derive(Clone, Debug)]
pub enum MTTError {
    AdditionMissingField(Name),
    CannotConvertMessageToRouteID,
    DocumentAlreadyExists(String),
    DocumentFieldAlreadyExists(String, Field),
    DocumentFieldMissing(String),
    DocumentFieldNotFound(String),
    DocumentFieldWrongDataType(FieldType, FieldType),
    DocumentNotFound(String),
    FieldDuplicate,
    FieldInvalidType,
    FieldMissingData,
    InvalidNone,
    RecordMismatch,
    NameDuplicate(Name),
    NameInvalidID(Uuid),
    NameMissingTranslation(Language),
    NameNotUniquePerLanguage(Name),
    NameNotFound(Name),
    QueryCannotChangeData,
    RouteRequiresDocumentID,
}

#[derive(Clone, Debug)]
pub enum ErrorID {
    InvalidDocumentName,
    InvalidFieldName(Name),
}

#[derive(Clone, Debug)]
struct MTTError2 {
    doc_name: NameType,
    error_id: ErrorID,
}

impl MTTError2 {
    pub fn new<NT>(doc_name: NT, error: ErrorID) -> MTTError2
    where
        NT: Into<NameType>,
    {
        Self {
            doc_name: doc_name.into(),
            error_id: error,
        }
    }

    pub fn error_id(&self) -> &ErrorID {
        &self.error_id
    }
}

impl fmt::Display for MTTError2 {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:?} error: {:?}", self.doc_name, self.error_id)
    }
}

impl Error for MTTError2 {}

impl MessageAction for MTTError2 {
    fn doc_name(&self) -> &NameType {
        &self.doc_name
    }
}

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

    #[test]
    fn can_create_error() {
        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
        let expected_name: NameType = doc_name.clone().into();
        let error = ErrorID::InvalidDocumentName;
        let err = MTTError2::new(doc_name.clone(), error.clone());
        assert_eq!(err.doc_name(), &expected_name);
        let err_id = err.error_id();
        match err_id {
            ErrorID::InvalidDocumentName => {}
            _ => unreachable!("got {:?}, should have been invalid document name", err_id),
        }
        assert_eq!(
            err.to_string(),
            format!("{:?} error: {:?}", NameType::Name(doc_name), error)
        );
    }

    #[test]
    fn does_error_ids_contain_data() {
        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
        let expected_name: NameType = doc_name.clone().into();
        let field_name = Name::english(Uuid::new_v4().to_string().as_str());
        let error = ErrorID::InvalidFieldName(field_name.clone());
        let err = MTTError2::new(doc_name.clone(), error.clone());
        assert_eq!(err.doc_name(), &expected_name);
        let err_id = err.error_id();
        match err_id {
            ErrorID::InvalidFieldName(data) => assert_eq!(data, &field_name),
            _ => unreachable!("got {:?}, should have been invalid field name", err_id),
        }
        assert_eq!(
            err.to_string(),
            format!("{:?} error: {:?}", NameType::Name(doc_name), error)
        );
    }
}