use morethantext::{action::*, ErrorID, Include, MoreThanText, Name, Path, TestMoreThanText};
use std::{
    sync::mpsc::{channel, RecvTimeoutError},
    time::Duration,
};
use uuid::Uuid;

pub static TIMEOUT: Duration = Duration::from_millis(500);

#[test]
fn are_errors_produced_for_duplicate_names() {
    let mut mtt = MoreThanText::new();
    let docdef = DocDef::new(Name::english("duplicate"));
    mtt.create_document(docdef.clone()).unwrap();
    match mtt.create_document(docdef) {
        Ok(_) => assert!(false, "should have failed"),
        Err(err) => match err.error_id() {
            ErrorID::NameAlreadyExists => {}
            _ => unreachable!("got {:?}, should be name already exists", err),
        },
    }
}

#[test]
fn does_document_respond_to() {
    let mut mtt = MoreThanText::new();
    let doc_name = TestMoreThanText::random_name();
    let mut requests: Vec<UserAction> = Vec::new();
    requests.push(Addition::new(doc_name.clone()).into());
    requests.push(Delete::new(doc_name.clone()).into());
    requests.push(Query::new(doc_name.clone()).into());
    requests.push(Update::new(doc_name.clone()).into());
    let docdef = DocDef::new(doc_name.clone());
    mtt.create_document(docdef).unwrap();
    for req in requests.iter() {
        let result = mtt.records(req.clone()).unwrap();
        assert_eq!(result.len(), 0, "from {:?}", req);
    }
}

#[test]
fn does_document_ignore_other_document_requests() {
    let mut mtt = TestMoreThanText::new();
    let quiet = Name::english("quiet");
    let alt = Name::english("alt");
    mtt.create_document(DocDef::new(quiet.clone())).unwrap();
    mtt.create_document(DocDef::new(alt.clone())).unwrap();
    let paths = vec![Path::new(
        Include::All,
        Include::Just(quiet.clone().into()),
        Include::All,
    )];
    let rx = mtt.register_channel(paths);
    let mut requests: Vec<UserAction> = Vec::new();
    requests.push(Addition::new(alt.clone()).into());
    requests.push(Delete::new(alt.clone()).into());
    requests.push(Query::new(alt.clone()).into());
    requests.push(Update::new(alt.clone()).into());
    for req in requests.iter() {
        mtt.records(req.clone()).unwrap();
    }
    match rx.recv_timeout(TIMEOUT) {
        Ok(msg) => unreachable!("got {:?} should have timed out", msg),
        Err(err) => match err {
            RecvTimeoutError::Timeout => {}
            _ => unreachable!("got {:?}, should have timed out", err),
        },
    }
}