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

#[derive(Clone, Debug)]
pub struct Update {
    doc_name: NameType,
    query: Query,
    values: RequestData,
}

impl Update {
    pub fn new<NT>(name: NT) -> Self
    where
        NT: Into<NameType>,
    {
        Self {
            doc_name: name.into(),
            query: Query::internal(),
            values: RequestData::new(),
        }
    }

    pub fn get_query(&self) -> &Query {
        &self.query
    }

    pub fn get_query_mut(&mut self) -> &mut Query {
        &mut self.query
    }

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

    pub fn get_values(&self) -> &RequestData {
        &self.values
    }

    pub fn get_values_mut(&mut self) -> &mut RequestData {
        &mut self.values
    }
}

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

#[cfg(test)]
mod updates {
    use super::*;
    use crate::{
        action::{Calculation, Operand},
        name::test_support::random_name,
    };

    #[test]
    fn is_default_update_empty() {
        let name = random_name();
        let expected: NameType = name.clone().into();
        let update = Update::new(name);
        assert_eq!(update.doc_name(), &expected);
        assert_eq!(update.get_query().iter().count(), 0);
        assert_eq!(update.get_values().iter().count(), 0);
    }

    #[test]
    fn can_update_query_be_altered() {
        let name = random_name();
        let expected: NameType = name.clone().into();
        let mut update = Update::new(name);
        let query = update.get_query_mut();
        let mut calc = Calculation::new(Operand::Equal);
        calc.add_value("something").unwrap();
        query.add(random_name(), calc);
        assert_eq!(update.doc_name(), &expected);
        assert_eq!(update.get_query().iter().count(), 1);
    }

    #[test]
    fn can_update_data_be_altered() {
        let name = random_name();
        let expected: NameType = name.clone().into();
        let mut update = Update::new(name);
        let values = update.get_values_mut();
        values.add_field(random_name(), "something");
        assert_eq!(update.doc_name(), &expected);
        assert_eq!(update.get_values().iter().count(), 1);
    }
}