//! Tests for [`super`].

use super::*;
use crate::test_helpers::insert_fake_sample;

fn setup() -> Database {
    Database::open_in_memory().unwrap()
}

#[test]
fn create_and_list_vfs() {
    let db = setup();
    let id = create_vfs(&db, "Library").unwrap();
    let list = list_vfs(&db).unwrap();
    assert_eq!(list.len(), 1);
    assert_eq!(list[0].id, id);
    assert_eq!(list[0].name, "Library");
}

#[test]
fn full_tree_excludes_tombstoned_files_keeps_folders() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Library").unwrap();
    let dir = create_directory(&db, vfs_id, None, "Drums").unwrap();
    insert_fake_sample(&db, "live");
    insert_fake_sample(&db, "dead");
    create_sample_link(
        &db,
        vfs_id,
        Some(dir),
        "live.wav",
        &crate::SampleHash::from_trusted("live"),
    )
    .unwrap();
    create_sample_link(
        &db,
        vfs_id,
        Some(dir),
        "dead.wav",
        &crate::SampleHash::from_trusted("dead"),
    )
    .unwrap();

    let before = list_full_tree(&db).unwrap();
    assert!(before.iter().any(|n| n.path.ends_with("dead.wav")));

    // Tombstone "dead": its leaf must vanish from the mirror's tree, but the
    // Drums folder (which still holds live.wav) must remain.
    crate::store::tombstone_sample(&db, "dead").unwrap();
    let after = list_full_tree(&db).unwrap();
    assert!(!after.iter().any(|n| n.path.ends_with("dead.wav")));
    assert!(after.iter().any(|n| n.path.ends_with("live.wav")));
    assert!(
        after
            .iter()
            .any(|n| n.node_type == NodeType::Directory && n.path.ends_with("Drums"))
    );
}

#[test]
fn rename_vfs_works() {
    let db = setup();
    let id = create_vfs(&db, "Old").unwrap();
    rename_vfs(&db, id, "New").unwrap();
    let list = list_vfs(&db).unwrap();
    assert_eq!(list[0].name, "New");
}

#[test]
fn delete_vfs_cascades_nodes() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Test").unwrap();
    create_directory(&db, vfs_id, None, "folder").unwrap();

    delete_vfs(&db, vfs_id).unwrap();

    let count: i64 = db
        .conn()
        .query_row("SELECT COUNT(*) FROM vfs_nodes", [], |row| row.get(0))
        .unwrap();
    assert_eq!(count, 0);
}

#[test]
fn directory_tree_crud() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();

    let dir_id = create_directory(&db, vfs_id, None, "Drums").unwrap();
    let sub_id = create_directory(&db, vfs_id, Some(dir_id), "Kicks").unwrap();

    let root_children = list_children(&db, vfs_id, None).unwrap();
    assert_eq!(root_children.len(), 1);
    assert_eq!(root_children[0].name, "Drums");

    let sub_children = list_children(&db, vfs_id, Some(dir_id)).unwrap();
    assert_eq!(sub_children.len(), 1);
    assert_eq!(sub_children[0].name, "Kicks");
    assert_eq!(sub_children[0].id, sub_id);
}

#[test]
fn sample_links() {
    let db = setup();
    insert_fake_sample(&db, "abc123");
    let vfs_id = create_vfs(&db, "Lib").unwrap();

    let node_id = create_sample_link(
        &db,
        vfs_id,
        None,
        "kick.wav",
        &crate::SampleHash::from_trusted("abc123"),
    )
    .unwrap();
    let node = get_node(&db, node_id).unwrap();
    assert_eq!(node.node_type, NodeType::Sample);
    assert_eq!(node.sample_hash.as_deref(), Some("abc123"));
}

#[test]
fn rename_and_move_node() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let dir_a = create_directory(&db, vfs_id, None, "A").unwrap();
    let dir_b = create_directory(&db, vfs_id, None, "B").unwrap();
    let child = create_directory(&db, vfs_id, Some(dir_a), "Child").unwrap();

    rename_node(&db, child, "Renamed").unwrap();
    let node = get_node(&db, child).unwrap();
    assert_eq!(node.name, "Renamed");

    move_node(&db, child, Some(dir_b)).unwrap();
    let node = get_node(&db, child).unwrap();
    assert_eq!(node.parent_id, Some(dir_b));
}

#[test]
fn delete_node_cascades() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let parent = create_directory(&db, vfs_id, None, "Parent").unwrap();
    create_directory(&db, vfs_id, Some(parent), "Child").unwrap();

    delete_node(&db, parent).unwrap();

    let count: i64 = db
        .conn()
        .query_row("SELECT COUNT(*) FROM vfs_nodes", [], |row| row.get(0))
        .unwrap();
    assert_eq!(count, 0);
}

#[test]
fn root_level_name_conflict() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    create_directory(&db, vfs_id, None, "Drums").unwrap();

    let result = create_directory(&db, vfs_id, None, "Drums");
    assert!(matches!(result, Err(CoreError::NameConflict(_))));
}

#[test]
fn root_name_uniqueness_enforced_by_index() {
    // The partial unique index (M029) is the backstop for the non-atomic
    // COUNT-then-INSERT check: a second same-name root insert must be
    // rejected by the DB even when it bypasses the Rust-side check, the
    // concurrent-insert race past check_root_name_conflict.
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    db.conn()
        .execute(
            "INSERT INTO vfs_nodes (vfs_id, parent_id, name, node_type, created_at)
             VALUES (?1, NULL, 'Drums', 'directory', 0)",
            rusqlite::params![vfs_id],
        )
        .unwrap();
    let dup = db.conn().execute(
        "INSERT INTO vfs_nodes (vfs_id, parent_id, name, node_type, created_at)
         VALUES (?1, NULL, 'Drums', 'directory', 0)",
        rusqlite::params![vfs_id],
    );
    assert!(
        dup.is_err(),
        "partial unique index must reject a duplicate root name"
    );
    assert!(crate::error::is_unique_violation(&dup.unwrap_err()));
}

#[test]
fn breadcrumb_trail() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let a = create_directory(&db, vfs_id, None, "A").unwrap();
    let b = create_directory(&db, vfs_id, Some(a), "B").unwrap();
    let c = create_directory(&db, vfs_id, Some(b), "C").unwrap();

    let crumbs = get_breadcrumb(&db, c).unwrap();
    assert_eq!(crumbs.len(), 3);
    assert_eq!(crumbs[0].name, "A");
    assert_eq!(crumbs[1].name, "B");
    assert_eq!(crumbs[2].name, "C");
}

#[test]
fn list_children_sorts_dirs_first() {
    let db = setup();
    insert_fake_sample(&db, "sample1");
    let vfs_id = create_vfs(&db, "Lib").unwrap();

    create_sample_link(
        &db,
        vfs_id,
        None,
        "zzz.wav",
        &crate::SampleHash::from_trusted("sample1"),
    )
    .unwrap();
    create_directory(&db, vfs_id, None, "AAA").unwrap();

    let children = list_children(&db, vfs_id, None).unwrap();
    assert_eq!(children[0].node_type, NodeType::Directory);
    assert_eq!(children[1].node_type, NodeType::Sample);
}

#[test]
fn collect_subtree_flat() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    insert_fake_sample(&db, "s1");
    let dir = create_directory(&db, vfs_id, None, "Dir").unwrap();
    create_sample_link(
        &db,
        vfs_id,
        Some(dir),
        "s1.wav",
        &crate::SampleHash::from_trusted("s1"),
    )
    .unwrap();

    let subtree = collect_subtree(&db, dir).unwrap();
    assert_eq!(subtree.len(), 2); // dir + sample
    assert!(subtree.iter().any(|n| n.name == "Dir"));
    assert!(subtree.iter().any(|n| n.name == "s1.wav"));
}

#[test]
fn collect_subtree_nested() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let a = create_directory(&db, vfs_id, None, "A").unwrap();
    let b = create_directory(&db, vfs_id, Some(a), "B").unwrap();
    create_directory(&db, vfs_id, Some(b), "C").unwrap();

    let subtree = collect_subtree(&db, a).unwrap();
    assert_eq!(subtree.len(), 3);
    let names: Vec<&str> = subtree.iter().map(|n| n.name.as_str()).collect();
    assert!(names.contains(&"A"));
    assert!(names.contains(&"B"));
    assert!(names.contains(&"C"));
}

#[test]
fn collect_subtree_empty_dir() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let dir = create_directory(&db, vfs_id, None, "Empty").unwrap();

    let subtree = collect_subtree(&db, dir).unwrap();
    assert_eq!(subtree.len(), 1);
    assert_eq!(subtree[0].name, "Empty");
}

#[test]
fn list_all_directories_works() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let drums = create_directory(&db, vfs_id, None, "Drums").unwrap();
    create_directory(&db, vfs_id, Some(drums), "Kicks").unwrap();
    create_directory(&db, vfs_id, Some(drums), "Snares").unwrap();
    create_directory(&db, vfs_id, None, "Vocals").unwrap();

    let dirs = list_all_directories(&db, vfs_id).unwrap();
    let paths: Vec<&str> = dirs.iter().map(|(_, p)| p.as_str()).collect();
    assert_eq!(
        paths,
        vec!["Drums", "Drums/Kicks", "Drums/Snares", "Vocals"]
    );
}

#[test]
fn list_all_directories_empty_vfs() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let dirs = list_all_directories(&db, vfs_id).unwrap();
    assert!(dirs.is_empty());
}

#[test]
fn enriched_query_includes_cloud_only_false() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    crate::test_helpers::insert_fake_sample(&db, "hash1");
    create_sample_link(
        &db,
        vfs_id,
        None,
        "kick.wav",
        &crate::SampleHash::from_trusted("hash1"),
    )
    .unwrap();

    let nodes = list_children_enriched(&db, vfs_id, None).unwrap();
    assert_eq!(nodes.len(), 1);
    assert!(!nodes[0].cloud_only);
}

#[test]
fn enriched_query_includes_cloud_only_true() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    crate::test_helpers::insert_fake_sample(&db, "hash1");
    create_sample_link(
        &db,
        vfs_id,
        None,
        "kick.wav",
        &crate::SampleHash::from_trusted("hash1"),
    )
    .unwrap();

    // Set cloud_only=1 directly
    db.conn()
        .execute("UPDATE samples SET cloud_only = 1 WHERE hash = 'hash1'", [])
        .unwrap();

    let nodes = list_children_enriched(&db, vfs_id, None).unwrap();
    assert_eq!(nodes.len(), 1);
    assert!(nodes[0].cloud_only);
}

#[test]
fn enriched_query_directory_cloud_only_false() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    create_directory(&db, vfs_id, None, "Drums").unwrap();

    let nodes = list_children_enriched(&db, vfs_id, None).unwrap();
    assert_eq!(nodes.len(), 1);
    // Directories have no sample_hash so cloud_only defaults to false
    assert!(!nodes[0].cloud_only);
}

#[test]
fn find_nodes_by_hashes_returns_correct_results() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    insert_fake_sample(&db, "hash_a");
    insert_fake_sample(&db, "hash_b");
    insert_fake_sample(&db, "hash_c");
    create_sample_link(
        &db,
        vfs_id,
        None,
        "a.wav",
        &crate::SampleHash::from_trusted("hash_a"),
    )
    .unwrap();
    create_sample_link(
        &db,
        vfs_id,
        None,
        "b.wav",
        &crate::SampleHash::from_trusted("hash_b"),
    )
    .unwrap();
    create_sample_link(
        &db,
        vfs_id,
        None,
        "c.wav",
        &crate::SampleHash::from_trusted("hash_c"),
    )
    .unwrap();

    let results = find_nodes_by_hashes(&db, vfs_id, &["hash_b", "hash_a"]).unwrap();

    // Returns results in input order
    assert_eq!(results.len(), 2);
    assert_eq!(results[0].node.sample_hash.as_deref(), Some("hash_b"));
    assert_eq!(results[1].node.sample_hash.as_deref(), Some("hash_a"));
}

#[test]
fn find_nodes_by_hashes_empty_input() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();

    let results = find_nodes_by_hashes(&db, vfs_id, &[]).unwrap();
    assert!(results.is_empty());
}

#[test]
fn find_nodes_by_hashes_nonexistent_hash() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();

    let results = find_nodes_by_hashes(&db, vfs_id, &["nonexistent"]).unwrap();
    assert!(results.is_empty());
}

#[test]
fn find_nodes_by_hashes_includes_cloud_only() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    insert_fake_sample(&db, "hash_cloud");
    create_sample_link(
        &db,
        vfs_id,
        None,
        "cloud.wav",
        &crate::SampleHash::from_trusted("hash_cloud"),
    )
    .unwrap();

    db.conn()
        .execute(
            "UPDATE samples SET cloud_only = 1 WHERE hash = 'hash_cloud'",
            [],
        )
        .unwrap();

    let results = find_nodes_by_hashes(&db, vfs_id, &["hash_cloud"]).unwrap();
    assert_eq!(results.len(), 1);
    assert!(results[0].cloud_only);
}

#[test]
fn move_node_rejects_circular_parent_to_child() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let a = create_directory(&db, vfs_id, None, "A").unwrap();
    let b = create_directory(&db, vfs_id, Some(a), "B").unwrap();
    let c = create_directory(&db, vfs_id, Some(b), "C").unwrap();

    // Moving A under C would create A -> B -> C -> A cycle
    let result = move_node(&db, a, Some(c));
    assert!(result.is_err());
    let err_msg = format!("{}", result.unwrap_err());
    assert!(
        err_msg.contains("circular"),
        "expected circular error, got: {err_msg}"
    );
}

#[test]
fn move_node_allows_valid_reparent() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let a = create_directory(&db, vfs_id, None, "A").unwrap();
    let b = create_directory(&db, vfs_id, Some(a), "B").unwrap();
    let c = create_directory(&db, vfs_id, Some(b), "C").unwrap();

    // Moving C under A (skipping B) is valid, no cycle
    move_node(&db, c, Some(a)).unwrap();
    let node = get_node(&db, c).unwrap();
    assert_eq!(node.parent_id, Some(a));
}

#[test]
fn move_node_to_root_succeeds() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let a = create_directory(&db, vfs_id, None, "A").unwrap();
    let b = create_directory(&db, vfs_id, Some(a), "B").unwrap();

    // Moving A to root is always valid
    move_node(&db, a, None).unwrap();
    let node = get_node(&db, a).unwrap();
    assert_eq!(node.parent_id, None);

    // Moving B to root is also valid
    move_node(&db, b, None).unwrap();
    let node = get_node(&db, b).unwrap();
    assert_eq!(node.parent_id, None);
}

#[test]
fn move_node_rejects_self_as_parent() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let a = create_directory(&db, vfs_id, None, "A").unwrap();

    // Moving A under itself creates a trivial cycle
    let result = move_node(&db, a, Some(a));
    assert!(result.is_err());
}

// --- Node name validation tests ---

#[test]
fn validate_node_name_accepts_valid_names() {
    assert!(validate_node_name("kick.wav").is_ok());
    assert!(validate_node_name("My Folder").is_ok());
    assert!(validate_node_name("drums-2024").is_ok());
    assert!(validate_node_name("a").is_ok());
    assert!(validate_node_name("...").is_ok()); // three dots is fine
}

#[test]
fn validate_node_name_rejects_empty() {
    let result = validate_node_name("");
    assert!(matches!(result, Err(CoreError::InvalidNodeName(_))));
}

#[test]
fn validate_node_name_rejects_dot() {
    let result = validate_node_name(".");
    assert!(matches!(result, Err(CoreError::InvalidNodeName(_))));
}

#[test]
fn validate_node_name_rejects_dotdot() {
    let result = validate_node_name("..");
    assert!(matches!(result, Err(CoreError::InvalidNodeName(_))));
}

#[test]
fn validate_node_name_rejects_forward_slash() {
    let result = validate_node_name("foo/bar");
    assert!(matches!(result, Err(CoreError::InvalidNodeName(_))));
}

#[test]
fn validate_node_name_rejects_backslash() {
    let result = validate_node_name("foo\\bar");
    assert!(matches!(result, Err(CoreError::InvalidNodeName(_))));
}

#[test]
fn validate_node_name_rejects_null_byte() {
    let result = validate_node_name("foo\0bar");
    assert!(matches!(result, Err(CoreError::InvalidNodeName(_))));
}

#[test]
fn create_directory_rejects_invalid_name() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let result = create_directory(&db, vfs_id, None, "..");
    assert!(matches!(result, Err(CoreError::InvalidNodeName(_))));
}

#[test]
fn create_sample_link_rejects_invalid_name() {
    let db = setup();
    insert_fake_sample(&db, "hash1");
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let result = create_sample_link(
        &db,
        vfs_id,
        None,
        "foo/bar.wav",
        &crate::SampleHash::from_trusted("hash1"),
    );
    assert!(matches!(result, Err(CoreError::InvalidNodeName(_))));
}

#[test]
fn rename_node_rejects_invalid_name() {
    let db = setup();
    let vfs_id = create_vfs(&db, "Lib").unwrap();
    let dir = create_directory(&db, vfs_id, None, "Valid").unwrap();
    let result = rename_node(&db, dir, "");
    assert!(matches!(result, Err(CoreError::InvalidNodeName(_))));
}

// --- list_full_tree tests ---

#[test]
fn list_full_tree_empty_vfs() {
    let db = setup();
    create_vfs(&db, "Lib").unwrap();
    let tree = list_full_tree(&db).unwrap();
    assert!(tree.is_empty());
}

#[test]
fn list_full_tree_builds_paths() {
    let db = setup();
    insert_fake_sample(&db, "s1");
    let vfs_id = create_vfs(&db, "Library").unwrap();
    let drums = create_directory(&db, vfs_id, None, "Drums").unwrap();
    let kicks = create_directory(&db, vfs_id, Some(drums), "Kicks").unwrap();
    create_sample_link(
        &db,
        vfs_id,
        Some(kicks),
        "808.wav",
        &crate::SampleHash::from_trusted("s1"),
    )
    .unwrap();

    let tree = list_full_tree(&db).unwrap();
    let paths: Vec<&str> = tree.iter().map(|n| n.path.as_str()).collect();
    assert_eq!(
        paths,
        vec![
            "Library/Drums",
            "Library/Drums/Kicks",
            "Library/Drums/Kicks/808.wav",
        ]
    );
    // Last node is a sample with the correct hash
    assert_eq!(tree[2].node_type, NodeType::Sample);
    assert_eq!(tree[2].sample_hash.as_deref(), Some("s1"));
}

#[test]
fn list_full_tree_multiple_vfs() {
    let db = setup();
    insert_fake_sample(&db, "s1");
    let v1 = create_vfs(&db, "Alpha").unwrap();
    let v2 = create_vfs(&db, "Beta").unwrap();
    create_directory(&db, v1, None, "Dir1").unwrap();
    create_sample_link(
        &db,
        v2,
        None,
        "sample.wav",
        &crate::SampleHash::from_trusted("s1"),
    )
    .unwrap();

    let tree = list_full_tree(&db).unwrap();
    let paths: Vec<&str> = tree.iter().map(|n| n.path.as_str()).collect();
    assert_eq!(paths, vec!["Alpha/Dir1", "Beta/sample.wav"]);
}