mod support;

use morethantext::{
    Addition, CalcValue, Calculation, Delete, ErrorID, Field, FieldType, IndexType, MTTError,
    MoreThanText, Name, 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 (test_env, test_doc) = setup_range(3);
    let mut mtt = test_env.get_morethantext();
    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 (test_env, test_doc) = setup_range(count.clone().try_into().unwrap());
    let mut mtt = test_env.get_morethantext();
    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
    );
}

#[test]
fn does_delete_error_on_a_bad_query() {
    let (test_env, test_doc) = setup_range(1);
    let mut mtt = test_env.get_morethantext();
    let bad_name = Name::japanese("正しくない");
    let mut delete = Delete::new(test_doc.get_doc_name());
    let mut qry_calc = Calculation::new(Operand::Equal);
    qry_calc.add_value(0).unwrap();
    qry_calc
        .add_value(CalcValue::Existing(FieldType::Integer))
        .unwrap();
    delete.get_query_mut().add(bad_name.clone(), qry_calc);
    let mut expected = MTTError::new(ErrorID::NameNotFound(bad_name.clone().into()));
    expected.add_parent(ErrorID::Field(bad_name.into()));
    expected.add_parent(ErrorID::Document(test_doc.get_doc_name().into()));
    let result = mtt.records(delete).unwrap_err();
    assert_eq!(result.to_string(), expected.to_string());
}

#[test]
fn does_delete_update_indexes() {
    let id = "something";
    let mut mtt = MoreThanText::new();
    let test_doc = TestDocument::new(vec![FieldType::StaticString]);
    let mut docdef = test_doc.get_docdef();
    docdef.add_index(&test_doc.get_field_name(0), IndexType::Unique);
    mtt.create_document(docdef).unwrap();
    test_doc.populate(&mut mtt, vec![id]);
    mtt.records(Delete::new(test_doc.get_doc_name())).unwrap();
    let mut add = Addition::new(test_doc.get_doc_name());
    add.add_field(test_doc.get_field_name(0), id);
    let result = mtt.records(add).unwrap();
    assert_eq!(result.len(), 1);
    let rec = result.iter().last().unwrap();
    assert_eq!(rec.get(test_doc.get_field_name(0)).unwrap(), id.into());
}