use super::{CalcValue, RequestData};
use crate::{message::MessageAction, name::NameType};

#[derive(Clone, Debug)]
pub struct Addition {
    data: RequestData,
    doc_name: NameType,
}

impl Addition {
    pub fn new<NT>(name: NT) -> Self
    where
        NT: Into<NameType>,
    {
        Self {
            data: RequestData::new(),
            doc_name: name.into(),
        }
    }

    pub fn add_field<NT, CV>(&mut self, name: NT, field: CV)
    where
        CV: Into<CalcValue>,
        NT: Into<NameType>,
    {
        self.data.add_field(name, field);
    }

    pub fn iter(&self) -> impl Iterator<Item = (&NameType, &CalcValue)> {
        self.data.iter()
    }
}

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

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

    #[test]
    fn is_default_addition_empty() {
        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
        let expected_name: NameType = doc_name.clone().into();
        let add = Addition::new(doc_name.clone());
        assert_eq!(add.doc_name(), &expected_name);
        assert_eq!(add.iter().count(), 0);
    }

    #[test]
    fn can_add_static_string() {
        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
        let mut add = Addition::new(doc_name);
        let name = Name::english(Uuid::new_v4().to_string().as_str());
        let ntype: NameType = name.clone().into();
        let data = Uuid::new_v4().to_string();
        add.add_field(name.clone(), data.clone());
        assert_eq!(add.iter().count(), 1);
        for (field_name, value) in add.iter() {
            assert_eq!(field_name, &ntype);
            match value {
                CalcValue::Value(result) => match result {
                    Field::StaticString(output) => assert_eq!(output, &data),
                    _ => unreachable!("got {:?}, should have been a string", result),
                },
                _ => unreachable!("got {:?}: should have received value", value),
            }
        }
    }

    #[test]
    fn can_add_uuid() {
        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
        let mut add = Addition::new(doc_name);
        let name = Name::english(Uuid::new_v4().to_string().as_str());
        let ntype: NameType = name.clone().into();
        let data = Uuid::new_v4();
        add.add_field(name.clone(), data.clone());
        assert_eq!(add.iter().count(), 1);
        for (field_name, value) in add.iter() {
            assert_eq!(field_name, &ntype);
            match value {
                CalcValue::Value(result) => match result {
                    Field::Uuid(output) => assert_eq!(output, &data),
                    _ => unreachable!("got {:?}, should have been a string", result),
                },
                _ => unreachable!("got {:?}: should have received value", value),
            }
        }
    }

    /*
    #[test]
    fn can_get_document() {
        let mut add = Addition::new();
        let name = Name::english(Uuid::new_v4().to_string().as_str());
        let data = Uuid::new_v4();
        add.add_field(name.clone(), data.clone());
        let doc = add.get_document();
        let output = doc.get_field(&name);
        match output {
            CalcValue::Value(holder) => match holder {
                Field::Uuid(result) => assert_eq!(result, &data),
                _ => unreachable!("should have received uuid"),
            },
            _ => unreachable!("got {:?}: should have received value", output),
        }
    }
    */
}