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

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

pub fn setup_range(count: usize) -> (TestMoreThanText, TestDocument) {
    let test_env = TestMoreThanText::new();
    let mut mtt = test_env.get_morethantext();
    let test_doc = TestDocument::new(vec![FieldType::Integer]);
    mtt.create_document(test_doc.get_docdef()).unwrap();
    let mut data: Vec<Vec<i128>> = Vec::new();
    for i in 0..count {
        let holder: i128 = i.try_into().unwrap();
        data.push(vec![holder]);
    }
    test_doc.populate_multiple(mtt.clone(), data);
    (test_env, test_doc)
}

pub struct TestDocument {
    docdef: DocDef,
    doc_name: Name,
    field_names: Vec<Name>,
}

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

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

    pub fn get_docdef(&self) -> DocDef {
        self.docdef.clone()
    }

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

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

    pub fn populate_multiple<F>(&self, mut mtt: 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();
        }
    }
}