mod support;

use morethantext::{
    CalcValue, Calculation, Delete, Field, FieldType, MoreThanText, Operand, Query,
};
use std::collections::HashSet;
use support::{setup_range, TestDocument};

#[test]
fn can_delete() {
    let data = "fred";
    let mut mtt = MoreThanText::new();
    let test_doc = TestDocument::new(vec![FieldType::StaticString]);
    mtt.create_document(test_doc.get_docdef()).unwrap();
    test_doc.populate(&mut mtt, vec![data]);
    let delete = Delete::new(test_doc.get_doc_name());
    let result = mtt.records(delete).unwrap();
    assert_eq!(result.len(), 1);
    let rec = result.iter().last().unwrap();
    assert_eq!(rec.get(test_doc.get_field_name(0)).unwrap(), data.into());
    let qry = Query::new(test_doc.get_doc_name());
    let qresult = mtt.records(qry).unwrap();
    assert_eq!(qresult.len(), 0);
}

#[test]
fn can_delete_specific() {
    let selected = 1;
    let (mut mtt, test_doc) = setup_range(3);
    let mut calc = Calculation::new(Operand::Equal);
    calc.add_value(selected.clone()).unwrap();
    calc.add_value(CalcValue::Existing(FieldType::Integer))
        .unwrap();
    let mut delete = Delete::new(test_doc.get_doc_name());
    delete.get_query_mut().add(test_doc.get_field_name(0), calc);
    let result = mtt.records(delete).unwrap();
    assert_eq!(result.len(), 1);
    let rec = result.iter().last().unwrap();
    assert_eq!(
        rec.get(test_doc.get_field_name(0)).unwrap(),
        selected.into()
    );
    let qry = Query::new(test_doc.get_doc_name());
    let qresult = mtt.records(qry).unwrap();
    assert_eq!(qresult.len(), 2);
    let mut expected: HashSet<Field> = HashSet::new();
    expected.insert(0.into());
    expected.insert(2.into());
    for qrec in qresult.iter() {
        if !expected.remove(&qrec.get(&test_doc.get_field_name(0)).unwrap()) {
            assert!(false, "{:?} should not have been stored", qrec);
        }
    }
    assert_eq!(
        expected.len(),
        0,
        "{:?} should have been in the query",
        expected
    );
}

#[test]
fn can_delete_multiple() {
    let count: i128 = 5;
    let selected: i128 = 2; // must be less than count and not less than 0
    let bound = selected + 1;
    let (mut mtt, test_doc) = setup_range(count.clone().try_into().unwrap());
    let mut calc = Calculation::new(Operand::GreaterThan);
    calc.add_value(CalcValue::Existing(FieldType::Integer))
        .unwrap();
    calc.add_value(selected.clone()).unwrap();
    let mut delete = Delete::new(test_doc.get_doc_name());
    delete.get_query_mut().add(test_doc.get_field_name(0), calc);
    let result = mtt.records(delete).unwrap();
    assert_eq!(result.len(), 2);
    let mut expected: HashSet<Field> = HashSet::new();
    for i in bound..count {
        expected.insert(i.into());
    }
    for rec in result.iter() {
        if !expected.remove(&rec.get(&test_doc.get_field_name(0)).unwrap()) {
            assert!(false, "{:?} should not have been deleted", rec);
        }
    }
    assert_eq!(expected.len(), 0, "{:?} should have been deleted", expected);
    let qry = Query::new(test_doc.get_doc_name());
    let qresult = mtt.records(qry).unwrap();
    assert_eq!(qresult.len(), bound.clone().try_into().unwrap());
    let mut qexpected: HashSet<Field> = HashSet::new();
    for i in 0..bound {
        qexpected.insert(i.into());
    }
    for rec in qresult.iter() {
        if !qexpected.remove(&rec.get(&test_doc.get_field_name(0)).unwrap()) {
            assert!(false, "{:?} should not have been deleted", rec);
        }
    }
    assert_eq!(
        qexpected.len(),
        0,
        "{:?} should have been deleted",
        qexpected
    );
}