extern crate tokio_core;

extern crate rincon_core;
extern crate rincon_connector;
extern crate rincon_client;
extern crate rincon_test_helper;

use rincon_core::api::connector::{Error, Execute};
use rincon_core::api::ErrorCode;
use rincon_client::collection::methods::*;
use rincon_client::collection::types::*;

use rincon_test_helper::*;


#[test]
fn create_collection_with_default_properties() {
    arango_test_with_user_db("test_coll_user1", "test_coll_db11", |conn, ref mut core| {

        let method = CreateCollection::with_name("test_collection1");
        let work = conn.execute(method);
        let collection = core.run(work).unwrap();

        assert_eq!("test_collection1", collection.name());
        assert_eq!(CollectionType::Documents, collection.kind());
        assert_eq!(CollectionStatus::Loaded, collection.status());
        assert!(!collection.is_system());
        assert!(!collection.is_wait_for_sync());

        #[cfg(feature = "mmfiles")]
        assert!(!collection.is_volatile());
    });
}

#[test]
fn create_edge_collection_with_wait_for_sync() {
    arango_test_with_user_db("test_coll_user2", "test_coll_db21", |conn, ref mut core| {

        let mut new_collection = NewCollection::edges_with_name("test_collection1");
        new_collection.set_wait_for_sync(Some(true));

        let method = CreateCollection::new(new_collection);
        let work = conn.execute(method);
        let collection = core.run(work).unwrap();

        assert_eq!("test_collection1", collection.name());
        assert_eq!(CollectionType::Edges, collection.kind());
        assert_eq!(CollectionStatus::Loaded, collection.status());
        assert!(!collection.is_system());
        assert!(collection.is_wait_for_sync());

        #[cfg(feature = "mmfiles")]
        assert!(!collection.is_volatile());
    });
}

#[test]
fn drop_collection_should_return_the_id_of_the_dropped_collection() {
    arango_test_with_user_db("test_coll_user3", "test_coll_db31", |conn, ref mut core| {

        let collection1 = core.run(conn.execute(CreateCollection::with_name("test_collection1"))).unwrap();
        let _ = core.run(conn.execute(CreateCollection::with_name("test_collection2"))).unwrap();

        let method = DropCollection::with_name("test_collection1");
        let work = conn.execute(method);
        let coll1_id = core.run(work).unwrap();

        assert_eq!(collection1.id(), coll1_id);
    });
}

#[test]
fn list_collections_should_return_two_collections() {
    arango_test_with_user_db("test_coll_user4", "test_coll_db41", |conn, ref mut core| {

        let _ = core.run(conn.execute(CreateCollection::documents_with_name("test_collection1"))).unwrap();
        let _ = core.run(conn.execute(CreateCollection::edges_with_name("test_collection2"))).unwrap();

        let method = ListCollections::new();
        let work = conn.execute(method);
        let collections = core.run(work).unwrap();

        let collection1 = collections.iter().find(|coll|
            coll.name() == "test_collection1").unwrap();

        assert_eq!("test_collection1", collection1.name());
        assert_eq!(CollectionType::Documents, collection1.kind());
        assert_eq!(CollectionStatus::Loaded, collection1.status());
        assert!(!collection1.is_system());

        let collection2 = collections.iter().find(|coll|
            coll.name() == "test_collection2").unwrap();

        assert_eq!("test_collection2", collection2.name());
        assert_eq!(CollectionType::Edges, collection2.kind());
        assert_eq!(CollectionStatus::Loaded, collection2.status());
        assert!(!collection2.is_system());
    });
}

#[test]
fn list_collections_should_return_empty_list() {
    arango_test_with_user_db("test_coll_user5", "test_coll_db51", |conn, ref mut core| {

        let method = ListCollections::new();
        let work = conn.execute(method);
        let collections = core.run(work).unwrap();

        assert!(collections.is_empty());
    });
}

#[test]
fn get_collection_should_return_collection_info() {
    arango_test_with_user_db("test_coll_user6", "test_coll_db61", |conn, ref mut core| {

        let _ = core.run(conn.execute(CreateCollection::documents_with_name("test_collection1"))).unwrap();
        let _ = core.run(conn.execute(CreateCollection::edges_with_name("test_collection2"))).unwrap();

        let method = GetCollection::with_name("test_collection2");
        let work = conn.execute(method);
        let collection = core.run(work).unwrap();

        assert_eq!("test_collection2", collection.name());
        assert_eq!(CollectionType::Edges, collection.kind());
        assert_eq!(CollectionStatus::Loaded, collection.status());
        assert!(!collection.is_system());
    });
}

#[test]
fn get_collection_should_return_an_error_if_collection_not_found() {
    arango_test_with_user_db("test_coll_user7", "test_coll_db71", |conn, ref mut core| {

        let _ = core.run(conn.execute(CreateCollection::documents_with_name("test_collection1"))).unwrap();
        let _ = core.run(conn.execute(CreateCollection::edges_with_name("test_collection2"))).unwrap();

        let method = GetCollection::with_name("test_collection_not_existing");
        let work = conn.execute(method);
        let result = core.run(work);

        match result {
            Err(Error::Method(error)) => {
                assert_eq!(404, error.status_code());
                assert_eq!(ErrorCode::ArangoCollectionNotFound, error.error_code());
                assert_eq!("unknown collection 'test_collection_not_existing'", error.message());
            },
            _ => panic!("Error::ApiError expected but got {:?}", result),
        };
    });
}

#[test]
fn get_collection_properties_should_return_collection_properties() {
    arango_test_with_user_db("test_coll_user8", "test_coll_db81", |conn, ref mut core| {

        let _ = core.run(conn.execute(CreateCollection::documents_with_name("test_collection1"))).unwrap();
        let _ = core.run(conn.execute(CreateCollection::edges_with_name("test_collection2"))).unwrap();

        let method = GetCollectionProperties::with_name("test_collection1");
        let work = conn.execute(method);
        let collection = core.run(work).unwrap();

        assert_eq!("test_collection1", collection.name());
        assert_eq!(CollectionType::Documents, collection.kind());
        assert_eq!(CollectionStatus::Loaded, collection.status());
        assert!(!collection.is_system());
        assert!(collection.key_options().is_allow_user_keys());
        assert_eq!(KeyGeneratorType::Traditional, collection.key_options().kind());
        assert_eq!(0, collection.key_options().last_value());
        assert!(!collection.is_wait_for_sync());

        #[cfg(feature = "mmfiles")]
        assert!(!collection.is_volatile());
        #[cfg(feature = "mmfiles")]
        assert!(collection.is_do_compact());
        #[cfg(feature = "mmfiles")]
        assert_eq!(8, collection.index_buckets());
    });
}

#[test]
fn get_collection_properties_should_return_an_error_if_collection_not_found() {
    arango_test_with_user_db("test_coll_user9", "test_coll_db91", |conn, ref mut core| {

        let _ = core.run(conn.execute(CreateCollection::documents_with_name("test_collection1"))).unwrap();
        let _ = core.run(conn.execute(CreateCollection::edges_with_name("test_collection2"))).unwrap();

        let method = GetCollectionProperties::with_name("test_collection_not_existing");
        let work = conn.execute(method);
        let result = core.run(work);

        match result {
            Err(Error::Method(error)) => {
                assert_eq!(404, error.status_code());
                assert_eq!(ErrorCode::ArangoCollectionNotFound, error.error_code());
                assert_eq!("unknown collection 'test_collection_not_existing'", error.message());
            },
            _ => panic!("Error::ApiError expected but got {:?}", result),
        };
    });
}

#[test]
fn change_collection_properties_wait_for_sync() {
    arango_test_with_user_db("test_coll_user10", "test_coll_db101", |conn, ref mut core| {

        let _ = core.run(conn.execute(CreateCollection::documents_with_name("test_collection1"))).unwrap();
        let original = core.run(conn.execute(GetCollectionProperties::with_name("test_collection1"))).unwrap();

        assert_eq!("test_collection1", original.name());
        assert!(!original.is_wait_for_sync());
        #[cfg(feature = "mmfiles")]
        assert_eq!(32 * 1024 * 1024, original.journal_size());

        let mut updates = CollectionPropertiesUpdate::new();
        updates.set_wait_for_sync(Some(true));
        let method = ChangeCollectionProperties::new("test_collection1".into(), updates);
        let work = conn.execute(method);
        let updated = core.run(work).unwrap();

        assert_eq!("test_collection1", updated.name());
        assert!(updated.is_wait_for_sync());
        #[cfg(feature = "mmfiles")]
        assert_eq!(32 * 1024 * 1024, updated.journal_size());
    });
}

#[cfg(feature = "mmfiles")]
#[test]
fn change_collection_properties_journal_size() {
    arango_test_with_user_db("test_coll_user11", "test_coll_db111", |conn, ref mut core| {

        let _ = core.run(conn.execute(CreateCollection::documents_with_name("test_collection1"))).unwrap();
        let original = core.run(conn.execute(GetCollectionProperties::with_name("test_collection1"))).unwrap();

        assert_eq!("test_collection1", original.name());
        assert!(!original.is_wait_for_sync());
        assert_eq!(32 * 1024 * 1024, original.journal_size());

        let mut updates = CollectionPropertiesUpdate::new();
        updates.set_journal_size(Some(128 * 1024 * 1024));
        let method = ChangeCollectionProperties::new("test_collection1".into(), updates);
        let work = conn.execute(method);
        let updated = core.run(work).unwrap();

        assert_eq!("test_collection1", updated.name());
        assert!(!updated.is_wait_for_sync());
        assert_eq!(128 * 1024 * 1024, updated.journal_size());
    });
}

#[test]
fn rename_collection_to_new_name() {
    arango_test_with_user_db("test_coll_user12", "test_coll_db121", |conn, ref mut core| {

        let original = core.run(conn.execute(CreateCollection::documents_with_name("test_collection1"))).unwrap();

        assert_eq!("test_collection1", original.name());

        let method = RenameCollection::with_name("test_collection1")
            .to_name("test_collection_renamed");
        let work = conn.execute(method);
        let updated = core.run(work).unwrap();

        assert_eq!("test_collection_renamed", updated.name());
    });
}

#[test]
fn rename_collection_to_empty_name() {
    arango_test_with_user_db("test_coll_user13", "test_coll_db131", |conn, ref mut core| {

        let original = core.run(conn.execute(CreateCollection::documents_with_name("test_collection1"))).unwrap();

        assert_eq!("test_collection1", original.name());

        let method = RenameCollection::with_name("test_collection1")
            .to_name("");
        let work = conn.execute(method);
        let result = core.run(work);

        match result {
            Err(Error::Method(error)) => {
                assert_eq!(403, error.status_code());
                assert_eq!(ErrorCode::Forbidden, error.error_code());
                assert_eq!("forbidden", error.message());
            },
            _ => panic!("Error::ApiError expected but got {:?}", result),
        }
    });
}

#[test]
fn get_collection_revision_of_new_collection() {
    arango_test_with_user_db("test_coll_user14", "test_coll_db141", |conn, ref mut core| {

        let original = core.run(conn.execute(CreateCollection::documents_with_name("test_collection1"))).unwrap();

        assert_eq!("test_collection1", original.name());

        let method = GetCollectionRevision::with_name("test_collection1");
        let work = conn.execute(method);
        let collection = core.run(work).unwrap();

        assert_eq!("test_collection1", collection.name());
        assert_eq!("0", collection.revision());
    });
}