#![cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]

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::ErrorCode;
use rincon_core::api::connector::{Error, Execute};
use rincon_client::index::methods::*;
use rincon_client::index::types::*;

use rincon_test_helper::*;


#[test]
fn get_index_list_from_document_collection() {
    arango_test_with_document_collection("index_customers01", |conn, ref mut core| {

        let method = GetIndexList::of_collection("index_customers01");
        let result = core.run(conn.execute(method)).unwrap();

        let indexes = result.indexes();
        let identifiers = result.identifiers();
        {
            let index1 = &indexes[0];
            let index_id = match *index1.id() {
                IndexIdOption::Qualified(ref index_id) => index_id,
                _ => panic!("Qualified index id expected!"),
            };
            assert_eq!("index_customers01/0", &index_id.to_string());
            assert_eq!(&vec!["_key".to_owned()][..], index1.fields());
            assert_eq!(false, index1.is_newly_created());
            if let &Index::Primary(ref primary_index) = index1 {
                assert_eq!(true, primary_index.is_unique());
                assert_eq!(1, primary_index.selectivity_estimate());
            } else {
                panic!("PrimaryIndex expected, but got {:?}", index1);
            }
        }
        {
            let identifier1 = identifiers.get("index_customers01/0").unwrap();
            let index_id = match *identifier1.id() {
                IndexIdOption::Qualified(ref index_id) => index_id,
                _ => panic!("Qualified index id expected!"),
            };
            assert_eq!("index_customers01/0", index_id.to_string());
            assert_eq!(&vec!["_key".to_owned()][..], identifier1.fields());
            assert_eq!(false, identifier1.is_newly_created());
            if let Index::Primary(ref primary_index) = *identifier1 {
                assert_eq!(true, primary_index.is_unique());
                assert_eq!(1, primary_index.selectivity_estimate());
            } else {
                panic!("PrimaryIndex expected, but got {:?}", identifier1);
            }
        }

        assert_eq!(1, indexes.len());
        assert_eq!(1, identifiers.len());
    });
}

#[test]
fn get_index_list_from_edge_collection() {
    arango_test_with_edge_collection("index_customers02", |conn, ref mut core| {

        let method = GetIndexList::of_collection("index_customers02");
        let result = core.run(conn.execute(method)).unwrap();

        let indexes = result.indexes();
        let identifiers = result.identifiers();
        {
            let index1 = &indexes[0];
            let index_id = match *index1.id() {
                IndexIdOption::Qualified(ref index_id) => index_id,
                _ => panic!("Qualified index id expected!"),
            };
            assert_eq!("index_customers02/0", &index_id.to_string());
            assert_eq!(&vec!["_key".to_owned()][..], index1.fields());
            assert_eq!(false, index1.is_newly_created());
            if let &Index::Primary(ref primary_index) = index1 {
                assert_eq!(true, primary_index.is_unique());
                assert_eq!(false, primary_index.is_sparse());
                assert_eq!(1, primary_index.selectivity_estimate());
            } else {
                panic!("PrimaryIndex expected, but got {:?}", index1);
            }
        }
        {
            let index2 = &indexes[1];
            let index_id = match *index2.id() {
                IndexIdOption::Qualified(ref index_id) => index_id,
                _ => panic!("Qualified index id expected!"),
            };
            assert_eq!("index_customers02/1", &index_id.to_string());
            assert_eq!(&vec!["_from".to_owned(), "_to".to_owned()][..], index2.fields());
            assert_eq!(false, index2.is_newly_created());
            if let &Index::Edge(ref edge_index) = index2 {
                assert_eq!(false, edge_index.is_unique());
                assert_eq!(false, edge_index.is_sparse());
            } else {
                panic!("EdgeIndex expected, but got {:?}", index2);
            }
        }
        {
            let identifier1 = identifiers.get("index_customers02/0").unwrap();
            let index_id = match *identifier1.id() {
                IndexIdOption::Qualified(ref index_id) => index_id,
                _ => panic!("Qualified index id expected!"),
            };
            assert_eq!("index_customers02/0", index_id.to_string());
            assert_eq!(&vec!["_key".to_owned()][..], identifier1.fields());
            assert_eq!(false, identifier1.is_newly_created());
            if let &Index::Primary(ref primary_index) = identifier1 {
                assert_eq!(true, primary_index.is_unique());
                assert_eq!(false, primary_index.is_sparse());
                assert_eq!(1, primary_index.selectivity_estimate());
            } else {
                panic!("PrimaryIndex expected, but got {:?}", identifier1);
            }
        }
        {
            let identifier2 = identifiers.get("index_customers02/1").unwrap();
            let index_id = match *identifier2.id() {
                IndexIdOption::Qualified(ref index_id) => index_id,
                _ => panic!("Qualified index id expected!"),
            };
            assert_eq!("index_customers02/1", index_id.to_string());
            assert_eq!(&vec!["_from".to_owned(), "_to".to_owned()][..], identifier2.fields());
            assert_eq!(false, identifier2.is_newly_created());
            if let &Index::Edge(ref edge_index) = identifier2 {
                assert_eq!(false, edge_index.is_unique());
                assert_eq!(false, edge_index.is_sparse());
            } else {
                panic!("EdgeIndex expected, but got {:?}", identifier2);
            }
        }

        assert_eq!(2, indexes.len());
        assert_eq!(2, identifiers.len());
    });
}

#[test]
fn get_index_from_collection() {
    arango_test_with_document_collection("index_customers03", |conn, ref mut core| {

        let method = GetIndex::new(IndexId::new("index_customers03", "0"));
        let index = core.run(conn.execute(method)).unwrap();
        let index_id = match *index.id() {
            IndexIdOption::Qualified(ref index_id) => index_id,
            _ => panic!("Qualified index id expected!"),
        };

        assert_eq!("index_customers03/0", index_id.to_string());
        assert_eq!(&vec!["_key".to_owned()][..], index.fields());
        assert_eq!(false, index.is_newly_created());
        if let Index::Primary(ref primary_index) = index {
            assert_eq!(true, primary_index.is_unique());
            assert_eq!(1, primary_index.selectivity_estimate());
        } else {
            panic!("PrimaryIndex expected, but got {:?}", index);
        }
    });
}

#[test]
fn create_index_of_type_hash_for_collection() {
    arango_test_with_document_collection("index_customers04", |conn, ref mut core| {

        let method = CreateIndex::new("index_customers04", NewHashIndex::new(
            vec!["name".to_owned()], true, false, true));
        let index = core.run(conn.execute(method)).unwrap();
        let index_id = match *index.id() {
            IndexIdOption::Qualified(ref index_id) => index_id,
            _ => panic!("Qualified index id expected!"),
        };

        assert_eq!("index_customers04", index_id.collection_name());
        assert!(!index_id.index_key().is_empty());
        assert_eq!(&vec!["name".to_owned()][..], index.fields());
        assert_eq!(true, index.is_newly_created());
        if let Index::Hash(ref hash_index) = index {
            assert_eq!(true, hash_index.is_unique());
            assert_eq!(false, hash_index.is_sparse());
            assert_eq!(true, hash_index.is_deduplicate());
            assert_eq!(1, hash_index.selectivity_estimate());
        } else {
            panic!("HashIndex expected, but got {:?}", index);
        }
    });
}

#[test]
fn create_index_of_type_skip_list_for_collection() {
    arango_test_with_document_collection("index_customers05", |conn, ref mut core| {

        let method = CreateIndex::new("index_customers05", NewSkipListIndex::new(
            vec!["age".to_owned(), "gender".to_owned()], false, true, false));
        let index = core.run(conn.execute(method)).unwrap();
        let index_id = match *index.id() {
            IndexIdOption::Qualified(ref index_id) => index_id,
            _ => panic!("Qualified index id expected!"),
        };

        assert_eq!("index_customers05", index_id.collection_name());
        assert!(!index_id.index_key().is_empty());
        assert_eq!(&vec!["age".to_owned(), "gender".to_owned()][..], index.fields());
        assert_eq!(true, index.is_newly_created());
        if let Index::SkipList(ref skip_list_index) = index {
            assert_eq!(false, skip_list_index.is_unique());
            assert_eq!(true, skip_list_index.is_sparse());
            assert_eq!(false, skip_list_index.is_deduplicate());
        } else {
            panic!("SkipListIndex expected, but got {:?}", index);
        }
    });
}

#[test]
fn create_index_of_type_persistent_for_collection() {
    arango_test_with_document_collection("index_customers06", |conn, ref mut core| {

        let method = CreateIndex::new("index_customers06", NewPersistentIndex::new(
            vec!["age".to_owned(), "gender".to_owned()], false, true));
        let index = core.run(conn.execute(method)).unwrap();
        let index_id = match *index.id() {
            IndexIdOption::Qualified(ref index_id) => index_id,
            _ => panic!("Qualified index id expected!"),
        };

        assert_eq!("index_customers06", index_id.collection_name());
        assert!(!index_id.index_key().is_empty());
        assert_eq!(&vec!["age".to_owned(), "gender".to_owned()][..], index.fields());
        assert_eq!(true, index.is_newly_created());
        if let Index::Persistent(ref persistent_index) = index {
            assert_eq!(false, persistent_index.is_unique());
            assert_eq!(true, persistent_index.is_sparse());
            assert_eq!(true, persistent_index.is_deduplicate());
        } else {
            panic!("PersistentIndex expected, but got {:?}", index);
        }
    });
}

#[test]
fn create_index_of_type_geo1_for_collection() {
    arango_test_with_document_collection("index_customers07", |conn, ref mut core| {

        let method = CreateIndex::new("index_customers07",
            NewGeoIndex::with_location_field("location", true));
        let index = core.run(conn.execute(method)).unwrap();
        let index_id = match *index.id() {
            IndexIdOption::Qualified(ref index_id) => index_id,
            _ => panic!("Qualified index id expected!"),
        };

        assert_eq!("index_customers07", index_id.collection_name());
        assert!(!index_id.index_key().is_empty());
        assert_eq!(&vec!["location".to_owned()][..], index.fields());
        assert_eq!(true, index.is_newly_created());
        if let Index::Geo1(ref geo_index) = index {
            assert_eq!(false, geo_index.is_unique());
            assert_eq!(true, geo_index.is_sparse());
            assert_eq!(true, geo_index.is_geo_json());
        } else {
            panic!("Geo1Index expected, but got {:?}", index);
        }
    });
}

#[test]
fn create_index_of_type_geo2_for_collection() {
    arango_test_with_document_collection("index_customers08", |conn, ref mut core| {

        let method = CreateIndex::new("index_customers08",
            NewGeoIndex::with_lat_lng_fields("latitude", "longitude"));
        let index = core.run(conn.execute(method)).unwrap();
        let index_id = match *index.id() {
            IndexIdOption::Qualified(ref index_id) => index_id,
            _ => panic!("Qualified index id expected!"),
        };

        assert_eq!("index_customers08", index_id.collection_name());
        assert!(!index_id.index_key().is_empty());
        assert_eq!(&vec!["latitude".to_owned(), "longitude".to_owned()][..], index.fields());
        assert_eq!(true, index.is_newly_created());
        if let Index::Geo2(ref geo_index) = index {
            assert_eq!(false, geo_index.is_unique());
            assert_eq!(true, geo_index.is_sparse());
        } else {
            panic!("Geo2Index expected, but got {:?}", index);
        }
    });
}

#[test]
fn create_index_of_type_fulltext_for_collection() {
    arango_test_with_document_collection("index_customers09", |conn, ref mut core| {

        let method = CreateIndex::new("index_customers09", NewFulltextIndex::with_field(
            "description", 4));
        let index = core.run(conn.execute(method)).unwrap();
        let index_id = match *index.id() {
            IndexIdOption::Qualified(ref index_id) => index_id,
            _ => panic!("Qualified index id expected!"),
        };

        assert_eq!("index_customers09", index_id.collection_name());
        assert!(!index_id.index_key().is_empty());
        assert_eq!(&vec!["description".to_owned()][..], index.fields());
        assert_eq!(true, index.is_newly_created());
        if let Index::Fulltext(ref fulltext_index) = index {
            assert_eq!(false, fulltext_index.is_unique());
            assert_eq!(true, fulltext_index.is_sparse());
            assert_eq!(4, fulltext_index.min_length());
        } else {
            panic!("FulltextIndex expected, but got {:?}", index);
        }
    });
}

#[test]
fn create_index_that_is_already_existing() {
    arango_test_with_document_collection("index_customers10", |conn, ref mut core| {

        let method = CreateIndex::new("index_customers10", NewFulltextIndex::with_field(
            "description", 4));
        let index = core.run(conn.execute(method)).unwrap();
        let index_id = match *index.id() {
            IndexIdOption::Qualified(ref index_id) => index_id,
            _ => panic!("Qualified index id expected!"),
        };

        assert_eq!("index_customers10", index_id.collection_name());
        assert!(!index_id.index_key().is_empty());
        assert_eq!(&vec!["description".to_owned()][..], index.fields());
        assert_eq!(true, index.is_newly_created());
        if let Index::Fulltext(ref fulltext_index) = index {
            assert_eq!(false, fulltext_index.is_unique());
            assert_eq!(true, fulltext_index.is_sparse());
            assert_eq!(4, fulltext_index.min_length());
        } else {
            panic!("FulltextIndex expected, but got {:?}", index);
        }

        let method = CreateIndex::new("index_customers10", NewFulltextIndex::with_field(
            "description", 4));
        let index2 = core.run(conn.execute(method)).unwrap();

        assert_eq!(index.id(), index2.id());
    });
}

#[test]
fn delete_index_of_type_hash_for_collection() {
    arango_test_with_document_collection("index_customers11", |conn, ref mut core| {

        let create = CreateIndex::new("index_customers11", NewHashIndex::new(
            vec!["name".to_owned()], true, false, true));
        let index = core.run(conn.execute(create)).unwrap();
        let index_id = match *index.id() {
            IndexIdOption::Qualified(ref index_id) => index_id,
            _ => panic!("Qualified index id expected!"),
        };

        let delete = DeleteIndex::new(index_id.clone());
        let index_id = core.run(conn.execute(delete)).unwrap();

        assert_eq!(index.id(), &index_id);
    });
}

#[test]
fn delete_not_existing_index_in_existing_collection() {
    arango_test_with_document_collection("index_customers12", |conn, ref mut core| {

        let create = CreateIndex::new("index_customers12", NewHashIndex::new(
            vec!["name".to_owned()], true, false, true));
        core.run(conn.execute(create)).unwrap();

        let delete = DeleteIndex::new(IndexId::new("index_customers12", "9999999"));
        let result = core.run(conn.execute(delete));

        match result {
            Err(Error::Method(error)) => {
                assert_eq!(404, error.status_code());
                assert_eq!(ErrorCode::ArangoIndexNotFound, error.error_code());
                assert_eq!("index not found", error.message());
            },
            _ => panic!("Expected error but got {:?}", result),
        }
    });
}