use morethantext::{Addition, DocDef, Field, FieldType, MoreThanText, Name};
use uuid::Uuid;

pub fn random_name() -> Name {
    Name::english(Uuid::new_v4().to_string().as_str())
}

pub struct TestDocument {
    doc_name: Name,
    field_names: Vec<Name>,
    field_types: Vec<FieldType>,
}

impl TestDocument {
    pub fn new(fields: Vec<FieldType>) -> Self {
        let mut fnames = Vec::new();
        for i in 0..fields.len() {
            let name = Name::english(format!("field{}", i).as_str());
            fnames.push(name);
        }
        Self {
            doc_name: random_name(),
            field_names: fnames,
            field_types: fields,
        }
    }

    pub fn get_doc_name(&self) -> &Name {
        &self.doc_name
    }

    pub fn get_docdef(&self) -> DocDef {
        let mut output = DocDef::new(self.doc_name.clone());
        for i in 0..self.field_types.len() {
            output.add_field(self.field_names[i].clone(), self.field_types[i].clone());
        }
        output
    }

    pub fn get_field_name(&self, position: usize) -> Name {
        self.field_names[position].clone()
    }

    pub fn populate<F>(&self, mtt: &mut MoreThanText, data: Vec<F>)
    where
        F: Into<Field> + Clone,
    {
        let wrapper = vec![data];
        self.populate_multiple(mtt, wrapper);
    }

    pub fn populate_multiple<F>(&self, mtt: &mut MoreThanText, data: Vec<Vec<F>>)
    where
        F: Into<Field> + Clone,
    {
        for rec in data.iter() {
            let mut add = Addition::new(self.doc_name.clone());
            for i in 0..self.field_names.len() {
                let field: Field = rec[i].clone().into();
                add.add_field(self.field_names[i].clone(), field);
            }
            mtt.records(add).unwrap();
        }
    }
}