use super::{Addition, DocDef, Query, Records, UserAction};
use crate::{
    message::{
        wrapper::{Delete, Reply, Update},
        MessageAction,
    },
    mtterror::MTTError,
    name::NameType,
    queue::data_director::Register,
};

#[derive(Clone, Debug)]
pub enum MsgAction {
    Addition(Addition),
    Create(DocDef),
    Error(MTTError),
    OnAddition(Records),
    OnDelete(Records),
    OnQuery(Records),
    OnUpdate(Records),
    Query(Query),
    Records(Records),
    Register(Register),
    Reply(Reply),
    Show,
    Delete(Delete),
    Update(Update),
}

impl MessageAction for MsgAction {
    fn doc_name(&self) -> &NameType {
        match self {
            Self::Addition(data) => data.doc_name(),
            Self::Create(data) => data.doc_name(),
            Self::Error(data) => data.doc_name(),
            Self::OnAddition(data) => data.doc_name(),
            Self::OnDelete(data) => data.doc_name(),
            Self::OnQuery(data) => data.doc_name(),
            Self::OnUpdate(data) => data.doc_name(),
            Self::Query(data) => data.doc_name(),
            Self::Records(data) => data.doc_name(),
            Self::Register(data) => data.doc_name(),
            _ => &NameType::None,
        }
    }
}

impl From<Addition> for MsgAction {
    fn from(value: Addition) -> Self {
        MsgAction::Addition(value)
    }
}

impl From<Delete> for MsgAction {
    fn from(value: Delete) -> Self {
        MsgAction::Delete(value)
    }
}

impl From<DocDef> for MsgAction {
    fn from(value: DocDef) -> Self {
        MsgAction::Create(value)
    }
}

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

impl From<Query> for MsgAction {
    fn from(value: Query) -> Self {
        MsgAction::Query(value)
    }
}

impl From<Records> for MsgAction {
    fn from(value: Records) -> Self {
        MsgAction::Records(value)
    }
}

impl From<Register> for MsgAction {
    fn from(value: Register) -> Self {
        MsgAction::Register(value)
    }
}

impl From<Reply> for MsgAction {
    fn from(value: Reply) -> Self {
        MsgAction::Reply(value)
    }
}

impl From<Update> for MsgAction {
    fn from(value: Update) -> Self {
        MsgAction::Update(value)
    }
}

impl From<UserAction> for MsgAction {
    fn from(value: UserAction) -> Self {
        match value {
            UserAction::CreateDocument(data) => Self::Create(data),
            UserAction::Query(data) => Self::Query(data),
        }
    }
}

#[cfg(test)]
mod msgactions {
    use super::*;
    use crate::{mtterror::ErrorID, name::Name};
    use uuid::Uuid;

    #[test]
    fn turn_document_definition_into_action() {
        let name = Name::english(Uuid::new_v4().to_string().as_str());
        let value = DocDef::new(name.clone());
        let result: MsgAction = value.into();
        match result {
            MsgAction::Create(def) => assert_eq!(def.get_document_names(), &[name].to_vec()),
            _ => unreachable!("Got {:?}: dhould have been create", result),
        }
    }

    #[test]
    fn turn_error_into_action() {
        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
        let expected_name: NameType = doc_name.clone().into();
        let error = ErrorID::DocumentNameAlreadyExists;
        let err = MTTError::new(doc_name.clone(), error.clone());
        let result: MsgAction = err.into();
        match result {
            MsgAction::Error(err) => {
                assert_eq!(err.doc_name(), &expected_name);
                let err_id = err.error_id();
                match err_id {
                    ErrorID::DocumentNameAlreadyExists => {}
                    _ => unreachable!("got {:?}, expected document name exists", err_id),
                }
            }
            _ => unreachable!("Got {:?}: dhould have been create", result),
        }
    }

    #[test]
    fn turn_query_into_action() {
        let name = Name::english(Uuid::new_v4().to_string().as_str());
        let expected_name: NameType = name.clone().into();
        let value = Query::new(name.clone());
        let result: MsgAction = value.into();
        match result {
            MsgAction::Query(data) => assert_eq!(data.doc_name(), &expected_name),
            _ => unreachable!("Got {:?}: dhould have been query", result),
        }
    }

    #[test]
    fn turn_reply_into_action() {
        let value = Reply::new();
        let result: MsgAction = value.into();
        match result {
            MsgAction::Reply(_) => {}
            _ => unreachable!("Got {:?}: dhould have been reply", result),
        }
    }
}