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

#[derive(Clone, Debug)]
pub enum ErrorID {
    Document(NameType),
    DocumentNameAlreadyExists,
    DocumentNotFound,
    FieldDataMustBeUnique,
    FieldInvalidNone,
    FieldInvalidType,
    FieldMissingData,
    FieldNameAlreadyExists,
    IndexEntryAlreadyExists,
    InvalidFieldName(Name),
    NameAlreadyExists,
    NameLanguageNotUnique,
    NameNotFound(NameType),
    TimeOut,
}

impl MessageAction for ErrorID {
    fn doc_name(&self) -> &NameType {
        match self {
            Self::Document(data) => data,
            _ => &NameType::None,
        }
    }
}

#[cfg(test)]
mod error_ids {
    use super::*;
    use crate::support_tests::random_name;

    #[test]
    fn do_errors_return_none_doc_name() {
        let errors = [ErrorID::FieldInvalidNone, ErrorID::FieldMissingData];
        for err in errors.iter() {
            assert_eq!(err.doc_name(), &NameType::None);
        }
    }

    #[test]
    fn does_document_error_return_document_name() {
        let name: NameType = random_name().into();
        let err = ErrorID::Document(name.clone());
        assert_eq!(err.doc_name(), &name);
    }
}

#[derive(Clone, Debug)]
pub struct MTTError {
    errors: VecDeque<ErrorID>,
}

impl MTTError {
    pub fn new(err: ErrorID) -> Self {
        let mut errs = VecDeque::new();
        errs.push_front(err);
        Self { errors: errs }
    }

    pub fn add_parent(&mut self, err: ErrorID) {
        self.errors.push_front(err);
    }

    pub fn get_error_ids(&self) -> &VecDeque<ErrorID> {
        &self.errors
    }
}

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

impl Error for MTTError {}

impl MessageAction for MTTError {
    fn doc_name(&self) -> &NameType {
        self.errors.front().unwrap().doc_name()
    }
}

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

    #[test]
    fn can_create_new_error() {
        let err = MTTError::new(ErrorID::FieldInvalidNone);
        assert_eq!(err.doc_name(), &NameType::None);
    }

    #[test]
    fn does_error_return_none_for_most_errors() {
        let base_err = ErrorID::FieldInvalidNone;
        let mut holder: VecDeque<ErrorID> = VecDeque::new();
        holder.push_front(base_err.clone());
        let expected = format!("error: {:?}", holder);
        let err = MTTError::new(base_err.clone());
        assert_eq!(err.to_string(), expected);
        assert_eq!(err.doc_name(), &NameType::None);
    }

    #[test]
    fn can_add_parent_error() {
        let base_err = ErrorID::FieldInvalidNone;
        let name: NameType = random_name().into();
        let doc_err = ErrorID::Document(name.clone());
        let mut err = MTTError::new(ErrorID::FieldInvalidNone);
        err.add_parent(doc_err.clone());
        let mut holder: VecDeque<ErrorID> = VecDeque::new();
        holder.push_front(base_err.clone());
        holder.push_front(doc_err.clone());
        let expected = format!("error: {:?}", holder);
        assert_eq!(err.to_string(), expected);
        assert_eq!(err.doc_name(), &name);
    }
}