use super::*;
use serde_json::json;
use std::path;

const TEST_DB_PATH: &str = "./fixtures/database";

const NO_DB_MESSAGE: &str = "Can not find/load test database";

#[test]
fn group_names() {
    let db = Database::new(path::Path::new(TEST_DB_PATH)).expect(NO_DB_MESSAGE);

    let names = db.group_names();
    assert!(names.contains(&"administration".to_owned()));
    assert!(names.contains(&"game".to_owned()));
    assert_eq!(names.len(), 2);
}

#[test]
fn file_names() {
    let db = Database::new(path::Path::new(TEST_DB_PATH)).expect(NO_DB_MESSAGE);

    let names_admin = db.file_names_in("administration");
    let names_game = db.file_names_in("game");
    assert!(names_admin.contains(&"registered".to_owned()));
    assert!(names_game.contains(&"general".to_owned()));
    assert!(names_game.contains(&"perks".to_owned()));
    assert_eq!(names_admin.len(), 1);
    assert_eq!(names_game.len(), 2);
}

#[test]
fn db_json_contents() {
    let db = Database::new(path::Path::new(TEST_DB_PATH)).expect(NO_DB_MESSAGE);
    let registered = db.as_json(("administration", "registered")).unwrap();
    let user_map = registered
        .as_object()
        .expect("Read value is not an object.");
    assert_eq!(user_map.len(), 2);
    assert!(user_map.contains_key("76561198025127722"));
    let user_record = user_map
        .get("76561198044316328")
        .unwrap()
        .as_object()
        .unwrap();
    assert_eq!(user_record.len(), 3);
    assert_eq!(user_record.get("ip_lock").unwrap().as_bool(), Some(false));
    assert_eq!(
        user_record.get("password_hash").unwrap().as_str(),
        Some("fce798e0804dfb217f929bdba26745024f37f6b6ba7406f3775176e20dd5089d")
    );

    let groups_arrays = user_record.get("groups").unwrap().as_array().unwrap();
    assert_eq!(groups_arrays.len(), 1);
    assert_eq!(groups_arrays[0], "admin");
}

#[test]
fn db_string_contents() {
    let db = Database::new(path::Path::new(TEST_DB_PATH)).expect(NO_DB_MESSAGE);
    let general = db.as_string(("game", "general")).unwrap();
    assert!(general.contains(r#""dosh_thrown":527624"#));
    assert!(general
        .contains(r#""achievements":["kf:LabCleaner","kf:ChickenFarmer","scrn:playedscrn"]"#));
}

#[test]
fn db_json_sub_contents() {
    let db = Database::new(path::Path::new(TEST_DB_PATH)).expect(NO_DB_MESSAGE);
    //  Test empty path
    let file_id = ("administration", "registered");
    assert_eq!(db.as_json(file_id), db.get_json(file_id, ""));
    //  Test complex path
    let received = db
        .get_json(file_id, "/76561198025127722/allowed_ips/1")
        .unwrap();
    assert_eq!(received.as_str().unwrap(), "192.168.0.100");
    //  Test bad paths
    assert!(db.get_json(file_id, "/777") == None);
    assert!(db.get_json(file_id, "/76561198025127722/allowed_ips/2") == None);
}

#[test]
fn db_string_sub_contents() {
    let db = Database::new(path::Path::new(TEST_DB_PATH)).expect(NO_DB_MESSAGE);
    //  Test empty path
    let file_id = ("administration", "registered");
    assert_eq!(db.as_string(file_id), db.get_string(file_id, ""));
    //  Test complex path
    let received = db
        .get_string(file_id, "/76561198025127722/allowed_ips/0")
        .unwrap();
    assert_eq!(received, r#""127.0.0.1""#);
}

#[test]
fn db_contains_check() {
    let db = Database::new(path::Path::new(TEST_DB_PATH)).expect(NO_DB_MESSAGE);
    let registered_id = ("administration", "registered");
    let perks_id = ("game", "perks");
    //  These exist
    assert!(db.contains(registered_id, "/76561198025127722/password_hash"));
    assert!(db.contains(registered_id, "/76561198044316328/groups"));
    assert!(db.contains(perks_id, "/76561198025127722/headshots"));
    assert!(db.contains(perks_id, "/76561198044316328"));
    //  These do not exist
    assert!(!db.contains(registered_id, "/76561198025127722/password/"));
    assert!(!db.contains(registered_id, "/76561198044316328/groups/2"));
    assert!(!db.contains(perks_id, "/76561198025127722/assault_rifle_damage/9067"));
    assert!(!db.contains(perks_id, "/76561198044316328/headshots"));
}

#[test]
fn db_set_success() -> Result<(), Box<dyn Error>> {
    let mut db = Database::new(path::Path::new(TEST_DB_PATH)).expect(NO_DB_MESSAGE);
    let file_id = ("administration", "registered");
    //  Modify existing
    db.set_json(file_id, "/76561198025127722/ip_lock", json!(false))?;
    assert_eq!(
        db.get_string(file_id, "/76561198025127722/ip_lock")
            .unwrap(),
        "false"
    );
    db.set_json(
        file_id,
        "/76561198044316328/password_hash",
        json!({"var":13524}),
    )?;
    assert_eq!(
        db.get_string(file_id, "/76561198044316328/password_hash")
            .unwrap(),
        r#"{"var":13524}"#
    );
    //  Reset whole file
    db.set_json(file_id, "", json!({}))?;
    assert_eq!(db.as_json(file_id).unwrap().to_string(), "{}");
    //  Add new values
    db.set_json(file_id, "/new_var", json!([42, {"word":"life"}, null]))?;
    assert_eq!(
        db.as_json(file_id).unwrap().to_string(),
        r#"{"new_var":[42,{"word":"life"},null]}"#
    );
    Ok(())
}

#[test]
fn test_pop_json_pointer() {
    assert_eq!(
        pop_json_pointer("/a/b/c/d"),
        Some(("/a/b/c".to_owned(), "d".to_owned()))
    );
    assert_eq!(pop_json_pointer("/"), Some(("".to_owned(), "".to_owned())));
    assert_eq!(
        pop_json_pointer("/a/b/"),
        Some(("/a/b".to_owned(), "".to_owned()))
    );
    assert_eq!(pop_json_pointer(""), None);
    //  This pointer is incorrect
    assert_eq!(pop_json_pointer("var"), None);
}