use super::*;

#[test]
fn virtual_catalog_compacts_and_retains_file_directory_collisions() {
    let mut picker = FilePicker::from_paths(
        PathBuf::new(),
        ["x", "x/y", "src/deep/deleted.rs", "src/deep/deleted.rs"]
            .map(PathBuf::from)
            .into_iter()
            .enumerate(),
    );
    assert_eq!(
        picker
            .entries()
            .map(|row| row.label.to_owned())
            .collect::<Vec<_>>(),
        ["src/deep", "x", "x"]
    );
    picker.reveal_path(Path::new("x"));
    assert!(!picker.entries().nth(picker.selected).unwrap().is_dir);
    assert_eq!(picker.accept(), Some(PathBuf::from("x")));
    picker.reveal_path(Path::new("x/y"));
    assert_eq!(picker.accept(), Some(PathBuf::from("x/y")));
    picker.reveal_path(Path::new("src/deep/deleted.rs"));
    assert_eq!(picker.accept(), Some(PathBuf::from("src/deep/deleted.rs")));
    assert_eq!(picker.entries().filter(|row| !row.is_dir).count(), 3);
    let expected_index = |row: &FileRow<'_>| {
        if row.is_dir {
            None
        } else {
            Some(match row.path.to_str().unwrap() {
                "x" => 0,
                "x/y" => 1,
                "src/deep/deleted.rs" => 2,
                path => panic!("unexpected path {path}"),
            })
        }
    };
    for view in [FileView::List, FileView::Tree] {
        picker.set_view(view);
        for query in ["", "x", "deleted"] {
            picker.query = query.into();
            picker.refilter();
            let rows: Vec<_> = picker.entries().collect();
            assert!(!rows.is_empty());
            for row in rows {
                assert_eq!(row.catalog_index, expected_index(&row));
                assert!(row.status.is_none() && row.old_path.is_none());
            }
        }
    }
}
use std::sync::atomic::{AtomicU64, Ordering};

static TEMP_ID: AtomicU64 = AtomicU64::new(0);
struct Directory(PathBuf);
impl Directory {
    fn new() -> Self {
        let id = TEMP_ID.fetch_add(1, Ordering::Relaxed);
        let path =
            std::env::temp_dir().join(format!("vamp-files-test-{}-{id}", std::process::id()));
        fs::create_dir(&path).unwrap();
        Self(path)
    }
    fn put(&self, name: &str, text: &str) {
        let path = self.0.join(name);
        fs::create_dir_all(path.parent().unwrap()).unwrap();
        fs::write(path, text).unwrap();
    }
    fn scan(&self) -> FilePicker {
        FilePicker::scan(self.0.clone(), FilePresentation::Floating, FileView::List).unwrap()
    }
}
impl Drop for Directory {
    fn drop(&mut self) {
        let _ = fs::remove_dir_all(&self.0);
    }
}
fn paths(picker: &FilePicker) -> Vec<PathBuf> {
    picker
        .entries()
        .map(|entry| entry.path.to_owned())
        .collect()
}

#[test]
fn fuzzy_path_tokens_preserve_tree_context_selection_and_open_paths() {
    let directory = Directory::new();
    let names = [
        "src/fuzzy_parser.rs",
        "src/über_parser.rs",
        "src/other.rs",
        "tests/fuzzy_parser.rs",
    ];
    for name in names {
        directory.put(name, "");
    }
    for mut picker in [
        directory.scan(),
        FilePicker::from_paths(
            directory.0.clone(),
            names.map(PathBuf::from).into_iter().enumerate(),
        ),
    ] {
        for view in [FileView::Tree, FileView::List] {
            picker.set_view(view);
            for (query, expected) in [
                ("sr/fp RS", "src/fuzzy_parser.rs"),
                ("ÜPR SRC", "src/über_parser.rs"),
            ] {
                picker.query = query.into();
                picker.refilter();
                assert_eq!(
                    picker
                        .entries()
                        .filter(|row| !row.is_dir)
                        .map(|row| row.path)
                        .collect::<Vec<_>>(),
                    [Path::new(expected)]
                );
                assert_eq!(selected_path(&picker), Path::new(expected));
                assert_eq!(picker.accept(), Some(directory.0.join(expected)));
                if view == FileView::Tree {
                    assert_eq!(paths(&picker), [Path::new("src"), Path::new(expected)]);
                }
            }
            picker.query = "rs/ü".into();
            picker.refilter();
            assert!(picker.entries().next().is_none());
            picker.clear_filter();
            assert_eq!(selected_path(&picker), Path::new("src/über_parser.rs"));
        }
    }
}

#[test]
fn scanned_files_and_directories_have_no_catalog_index() {
    let directory = Directory::new();
    directory.put("nested/file.txt", "");
    let mut picker = directory.scan();
    for view in [FileView::List, FileView::Tree] {
        picker.set_view(view);
        picker.reveal_path(Path::new("nested/file.txt"));
        assert!(picker.entries().all(|row| row.catalog_index.is_none()));
        assert!(
            picker
                .entries()
                .all(|row| row.status.is_none() && row.old_path.is_none())
        );
    }
}

fn repository_change(path: &str, status: FileStatus, old_path: Option<&str>) -> WorkingFileChange {
    WorkingFileChange {
        path: path.into(),
        status,
        old_path: old_path.map(PathBuf::from),
    }
}

#[test]
fn repository_metadata_keeps_clean_files_selection_and_filtered_views() {
    let directory = Directory::new();
    for name in ["src/clean.rs", "src/modified.rs", "added.rs", "renamed.rs"] {
        directory.put(name, "");
    }
    let mut picker = directory.scan();
    picker.presentation = FilePresentation::Docked;
    picker.set_view(FileView::Tree);
    picker.reveal_path(Path::new("src/clean.rs"));
    picker.query = "src".into();
    picker.refilter();
    picker.focused = false;
    let changes = vec![
        repository_change("src/modified.rs", FileStatus::Modified, None),
        repository_change("added.rs", FileStatus::Added, None),
        repository_change("renamed.rs", FileStatus::Renamed, Some("old.rs")),
        repository_change("vanished/deep/deleted.rs", FileStatus::Removed, None),
    ];
    assert!(picker.set_repository_changes(changes.clone()));
    assert!(!picker.set_repository_changes(changes));
    assert_eq!(selected_path(&picker), Path::new("src/clean.rs"));
    assert_eq!(picker.query, "src");
    assert!(!picker.focused);
    assert_eq!(picker.presentation, FilePresentation::Docked);
    for view in [FileView::List, FileView::Tree] {
        picker.set_view(view);
        for query in ["", "src", "modified.rs", "deleted.rs"] {
            picker.query = query.into();
            picker.refilter();
            let rows: Vec<_> = picker.entries().collect();
            assert!(!rows.is_empty());
            for row in rows {
                assert!(row.catalog_index.is_none());
                if row.is_dir || row.path == Path::new("src/clean.rs") {
                    assert!(row.status.is_none() && row.old_path.is_none());
                } else {
                    let status = match row.path.to_str().unwrap() {
                        "src/modified.rs" => FileStatus::Modified,
                        "added.rs" => FileStatus::Added,
                        "renamed.rs" => FileStatus::Renamed,
                        "vanished/deep/deleted.rs" => FileStatus::Removed,
                        other => panic!("unexpected {other}"),
                    };
                    assert_eq!(row.status, Some(status));
                    assert_eq!(
                        row.old_path,
                        (status == FileStatus::Renamed).then(|| Path::new("old.rs"))
                    );
                }
            }
            if query.is_empty() || query == "src" {
                assert!(
                    picker
                        .entries()
                        .any(|row| row.path == Path::new("src/clean.rs"))
                );
            }
        }
    }
    picker.set_view(FileView::List);
    picker.clear_filter();
    picker.reveal_path(Path::new("src/clean.rs"));
    assert!(picker.set_repository_changes(Vec::new()));
    assert_eq!(selected_path(&picker), Path::new("src/clean.rs"));
    assert_eq!(picker.entries().len(), 4);
    assert!(picker.nodes.iter().all(|node| !node.virtual_entry));
    assert!(
        picker
            .entries()
            .all(|row| row.status.is_none() && row.old_path.is_none())
    );
    assert!(!picker.set_repository_changes(Vec::new()));
}

#[test]
fn deleted_catalog_leaves_survive_refresh_and_restored_files_survive_clear() {
    let directory = Directory::new();
    directory.put("keep.txt", "");
    let mut picker = directory.scan();
    let deleted = Path::new("lost/deep/deleted.txt");
    picker.set_repository_changes(vec![repository_change(
        "lost/deep/deleted.txt",
        FileStatus::Removed,
        None,
    )]);
    picker.set_view(FileView::Tree);
    assert_eq!(
        picker.entries().find(|row| row.is_dir).unwrap().label,
        "lost/deep"
    );
    picker.reveal_path(deleted);
    picker.query = "deleted".into();
    picker.refilter();
    picker.start_search();
    picker.focused = false;
    picker.refresh();
    assert_eq!(selected_path(&picker), deleted);
    assert!(picker.searching && !picker.focused);
    assert_eq!(picker.query, "deleted");
    assert_eq!(picker.accept(), Some(directory.0.join(deleted)));
    assert!(!directory.0.join(deleted).exists());
    assert_eq!(
        picker.entries().find(|row| !row.is_dir).unwrap().status,
        Some(FileStatus::Removed)
    );
    directory.put("lost/deep/deleted.txt", "restored");
    assert!(picker.set_repository_changes(vec![repository_change(
        "lost/deep/deleted.txt",
        FileStatus::Removed,
        None,
    )]));
    picker.refresh();
    assert_eq!(selected_path(&picker), deleted);
    assert!(picker.nodes.iter().all(|node| !node.virtual_entry));
    assert!(picker.set_repository_changes(Vec::new()));
    assert_eq!(selected_path(&picker), deleted);
    assert_eq!(picker.accept(), Some(directory.0.join(deleted)));
    assert_eq!(
        fs::read_to_string(directory.0.join(deleted)).unwrap(),
        "restored"
    );
    assert!(picker.entries().all(|row| row.status.is_none()));
    fs::remove_dir_all(directory.0.join("lost")).unwrap();
    picker.refresh();
    picker.set_repository_changes(vec![repository_change(
        "lost/deep/deleted.txt",
        FileStatus::Removed,
        None,
    )]);
    picker.reveal_path(deleted);
    picker.set_repository_changes(Vec::new());
    assert!(picker.entries().len() == 0);
    picker.clear_filter();
    assert_eq!(paths(&picker), [PathBuf::from("keep.txt")]);
    assert!(picker.nodes.iter().all(|node| !node.virtual_entry));
}

#[test]
fn repository_metadata_cannot_introduce_unsafe_or_existing_excluded_paths() {
    let directory = Directory::new();
    directory.put(".gitignore", "ignored/\n");
    directory.put("ignored/hidden.txt", "");
    directory.put("directory/keep.txt", "");
    let mut picker = directory.scan();
    let mut changes: Vec<_> = [
        "",
        ".",
        "../outside.txt",
        "directory/../../outside.txt",
        ".git/secret",
        "nested/.jj/secret",
        "/outside.txt",
        "directory",
        "ignored/hidden.txt",
    ]
    .into_iter()
    .map(|path| repository_change(path, FileStatus::Removed, None))
    .collect();
    #[cfg(unix)]
    {
        std::os::unix::fs::symlink(&directory.0, directory.0.join("link")).unwrap();
        changes.push(repository_change(
            "link/missing.txt",
            FileStatus::Removed,
            None,
        ));
    }
    changes.push(repository_change("missing.txt", FileStatus::Removed, None));
    picker.set_repository_changes(changes);
    assert_eq!(
        paths(&picker),
        [".gitignore", "directory/keep.txt", "missing.txt"].map(PathBuf::from)
    );
    assert_eq!(
        picker.entries().filter(|row| row.status.is_some()).count(),
        1
    );
    assert_eq!(
        picker.entries().last().unwrap().status,
        Some(FileStatus::Removed)
    );
    assert!(!directory.0.join("missing.txt").exists());
}

#[test]
fn nested_ignore_negation_hidden_files_and_vcs_metadata() {
    let directory = Directory::new();
    directory.put(".gitignore", "*.log\nignored/\n");
    directory.put("nested/.gitignore", "!keep.log\nlocal.txt\n");
    for name in [
        "gone.log",
        "nested/gone.log",
        "nested/keep.log",
        "nested/local.txt",
        "nested/ok.txt",
        "ignored/hidden.txt",
        ".hidden",
        ".git/objects/secret",
        "nested/.git/secret",
        ".jj/secret",
        "nested/.jj/secret",
    ] {
        directory.put(name, "text");
    }
    let picker = directory.scan();
    assert_eq!(
        paths(&picker),
        [
            ".gitignore",
            ".hidden",
            "nested/.gitignore",
            "nested/keep.log",
            "nested/ok.txt"
        ]
        .map(PathBuf::from)
    );
    assert!(picker.error.is_none());
}

#[test]
fn literal_unicode_tokens_grapheme_deletion_and_navigation() {
    let directory = Directory::new();
    for name in ["a space 界[e\u{301}].txt", "b.txt", "c.txt"] {
        directory.put(name, "text");
    }
    let mut picker = directory.scan();
    picker.navigate(false);
    assert_eq!(picker.selected, 2);
    picker.navigate(true);
    assert_eq!(picker.selected, 0);
    picker.query = "界 SPACE [E\u{301}]".into();
    picker.refilter();
    assert_eq!(paths(&picker), [PathBuf::from("a space 界[e\u{301}].txt")]);
    picker.query = "e\u{301}👩‍💻".into();
    assert!(picker.handle_filter_input(&crate::editor::Input::Backspace));
    assert_eq!(picker.query, "e\u{301}");
    assert!(picker.handle_filter_input(&crate::editor::Input::Backspace));
    assert_eq!(picker.query, "");
    assert!(picker.handle_filter_input(&crate::editor::Input::Backspace));
    assert_eq!(picker.entries().len(), 3);
    picker.query = "no match".into();
    picker.refilter();
    for forward in [true, false] {
        picker.navigate(forward);
        assert_eq!(picker.selected, 0);
        assert_eq!(picker.entries().len(), 0);
    }
}

#[test]
fn word_and_line_deletion_refilter_only_editable_queries() {
    use crate::editor::Input;

    for view in [FileView::List, FileView::Tree] {
        let mut picker = FilePicker::from_paths(
            PathBuf::new(),
            ["alpha one.txt", "alpha two.txt", "beta.txt"]
                .map(PathBuf::from)
                .into_iter()
                .enumerate(),
        );
        picker.set_view(view);
        picker.query = "alpha missing".into();
        picker.refilter();
        assert_eq!(picker.entries().len(), 0);
        if view == FileView::Tree {
            for input in [Input::Backspace, Input::AltBackspace, Input::SuperBackspace] {
                assert!(!picker.handle_filter_input(&input));
                assert_eq!(picker.query, "alpha missing");
            }
            picker.start_search();
        }
        assert!(picker.handle_filter_input(&Input::AltBackspace));
        assert_eq!(picker.query, "alpha ");
        assert_eq!(picker.entries().len(), 2);
        assert!(picker.handle_filter_input(&Input::SuperBackspace));
        assert_eq!(picker.query, "");
        assert_eq!(picker.entries().len(), 3);
        for input in [Input::Backspace, Input::AltBackspace, Input::SuperBackspace] {
            assert!(picker.handle_filter_input(&input));
            assert_eq!(picker.entries().len(), 3);
        }
    }
}

#[test]
fn empty_scan_refresh_and_failure_preserve_reachable_state() {
    let directory = Directory::new();
    let mut picker = directory.scan();
    picker.navigate(false);
    assert!(picker.handle_filter_input(&crate::editor::Input::Backspace));
    assert_eq!(picker.entries().len(), 0);
    directory.put("new.txt", "text");
    picker.query = "new".into();
    picker.refresh();
    assert_eq!(picker.query, "new");
    assert_eq!(paths(&picker), [PathBuf::from("new.txt")]);
    fs::remove_dir_all(&directory.0).unwrap();
    picker.refresh();
    assert_eq!(paths(&picker), [PathBuf::from("new.txt")]);
    assert!(picker.error.as_ref().unwrap().contains("Refresh failed"));
    assert!(
        FilePicker::scan(
            directory.0.clone(),
            FilePresentation::Docked,
            FileView::Tree
        )
        .is_err()
    );
}

#[test]
fn malformed_ignore_warning_survives_query_and_navigation() {
    let directory = Directory::new();
    directory.put(".gitignore", "[z-a]\n");
    directory.put("ok.txt", "text");
    let mut picker = directory.scan();
    assert!(picker.error.as_ref().unwrap().contains("Incomplete scan"));
    picker.query = "ok".into();
    picker.refilter();
    assert_eq!(paths(&picker), [PathBuf::from("ok.txt")]);
    picker.navigate(true);
    assert!(picker.error.as_ref().unwrap().contains("Incomplete scan"));
    directory.put(".gitignore", "");
    picker.refresh();
    assert!(picker.error.is_none());
}

#[test]
fn only_project_ignore_rules_apply_and_non_directory_roots_fail() {
    let directory = Directory::new();
    directory.put(".gitignore", "*.txt\n");
    directory.put("project/visible.txt", "text");
    let root = directory.0.join("project");
    let picker = FilePicker::scan(root, FilePresentation::Floating, FileView::List).unwrap();
    assert_eq!(paths(&picker), [PathBuf::from("visible.txt")]);
    assert!(
        FilePicker::scan(
            directory.0.join("project/visible.txt"),
            FilePresentation::Docked,
            FileView::Tree,
        )
        .is_err()
    );
}

#[cfg(unix)]
#[test]
fn symlink_loops_and_file_links_are_not_followed_and_raw_paths_survive() {
    use std::os::unix::fs::symlink;
    let directory = Directory::new();
    directory.put("real.txt", "text");
    symlink(&directory.0, directory.0.join("loop")).unwrap();
    symlink(directory.0.join("real.txt"), directory.0.join("alias.txt")).unwrap();
    let raw = PathBuf::from("raw界\n.txt");
    fs::write(directory.0.join(&raw), "text").unwrap();
    let picker = directory.scan();
    assert_eq!(picker.entries().len(), 2);
    let entry = picker
        .entries()
        .find(|entry| entry.path == raw.as_path())
        .unwrap();
    assert!(!entry.label.chars().any(char::is_control));
    assert_eq!(
        fs::read_to_string(directory.0.join(entry.path)).unwrap(),
        "text"
    );
}

fn tree(directory: &Directory) -> FilePicker {
    FilePicker::scan(
        directory.0.clone(),
        FilePresentation::Docked,
        FileView::Tree,
    )
    .unwrap()
}

fn select(picker: &mut FilePicker, path: &str) {
    let selected = picker
        .entries()
        .position(|row| row.path == Path::new(path))
        .unwrap();
    picker.selected = selected;
}

fn selected_path(picker: &FilePicker) -> &Path {
    picker.entries().nth(picker.selected).unwrap().path
}

#[test]
fn tree_orders_folders_first_keeps_empty_dirs_and_compacts_only_directory_chains() {
    let directory = Directory::new();
    directory.put("a.txt", "");
    directory.put("folder/only.txt", "");
    directory.put("chain/one/two/a.txt", "");
    directory.put("chain/one/two/z.txt", "");
    fs::create_dir(directory.0.join("empty")).unwrap();
    let mut picker = tree(&directory);
    assert_eq!(picker.view, FileView::Tree);
    assert!(!picker.searching);
    assert_eq!(
        picker
            .entries()
            .map(|row| (row.label, row.is_dir, row.depth))
            .collect::<Vec<_>>(),
        [
            ("chain/one/two", true, 0),
            ("empty", true, 0),
            ("folder", true, 0),
            ("a.txt", false, 0)
        ]
    );
    assert_eq!(selected_path(&picker), Path::new("chain/one/two"));
    picker.right();
    assert_eq!(
        picker
            .entries()
            .map(|row| (row.label, row.depth))
            .collect::<Vec<_>>(),
        [
            ("chain/one/two", 0),
            ("a.txt", 1),
            ("z.txt", 1),
            ("empty", 0),
            ("folder", 0),
            ("a.txt", 0)
        ]
    );
    picker.right();
    assert_eq!(selected_path(&picker), Path::new("chain/one/two/a.txt"));
    let rows = paths(&picker);
    picker.right();
    assert_eq!(paths(&picker), rows);
    picker.left();
    assert_eq!(selected_path(&picker), Path::new("chain/one/two"));
    picker.left();
    assert!(!picker.entries().next().unwrap().expanded);
    picker.left();
    assert_eq!(picker.selected, 0);
    select(&mut picker, "folder");
    assert!(picker.accept().is_none());
    assert_eq!(
        picker.entries().nth(picker.selected + 1).unwrap().label,
        "only.txt"
    );
    picker.right();
    assert_eq!(picker.accept(), Some(directory.0.join("folder/only.txt")));
    select(&mut picker, "empty");
    picker.right();
    assert!(picker.entries().nth(picker.selected).unwrap().expanded);
    picker.right();
    assert_eq!(selected_path(&picker), Path::new("empty"));
}

#[test]
fn tree_search_reveals_ancestors_without_mutating_saved_expansion_or_compaction() {
    let directory = Directory::new();
    directory.put("src/module/deep/needle.txt", "");
    directory.put("src/module/sibling.txt", "");
    directory.put("src/root.txt", "");
    directory.put("other/keep.txt", "");
    let mut picker = tree(&directory);
    select(&mut picker, "other");
    picker.right();
    select(&mut picker, "src");
    let expanded = picker.expanded.clone();
    picker.start_search();
    picker.query = "NEEDLE".into();
    picker.refilter();
    assert_eq!(
        picker
            .entries()
            .map(|row| (row.label, row.depth))
            .collect::<Vec<_>>(),
        [("src", 0), ("module", 1), ("deep", 2), ("needle.txt", 3)]
    );
    assert_eq!(
        selected_path(&picker),
        Path::new("src/module/deep/needle.txt")
    );
    assert_eq!(picker.expanded, expanded);
    picker.left();
    let filtered = paths(&picker);
    picker.finish_search();
    assert_eq!(picker.query, "NEEDLE");
    assert_eq!(paths(&picker), filtered);
    assert_eq!(selected_path(&picker), Path::new("src/module/deep"));
    assert_eq!(picker.expanded, expanded);
    picker.start_search();
    picker.query = "deep".into();
    picker.refilter();
    select(&mut picker, "src/module/deep");
    assert!(picker.accept().is_none());
    assert!(!picker.searching);
    assert_eq!(picker.query, "deep");
    assert_eq!(selected_path(&picker), Path::new("src/module/deep"));
    assert!(!picker.entries().nth(picker.selected).unwrap().expanded);
    assert_eq!(picker.expanded, expanded);
    picker.right();
    assert!(picker.entries().nth(picker.selected).unwrap().expanded);
    assert_eq!(picker.query, "deep");

    let chain = Directory::new();
    chain.put("one/two/three/a.txt", "");
    chain.put("one/two/three/b.txt", "");
    let mut picker = tree(&chain);
    picker.start_search();
    picker.query = "a.txt".into();
    picker.refilter();
    assert_eq!(
        picker.entries().map(|row| row.label).collect::<Vec<_>>(),
        ["one/two/three", "a.txt"]
    );
}

#[test]
fn view_switches_restore_directory_choices_and_reveal_explicit_file_choices() {
    let directory = Directory::new();
    directory.put("src/a.txt", "");
    directory.put("src/b.txt", "");
    directory.put("z.txt", "");
    let mut picker = tree(&directory);
    picker.right();
    let open = paths(&picker);
    picker.set_view(FileView::List);
    assert_eq!(
        paths(&picker),
        ["src/a.txt", "src/b.txt", "z.txt"].map(PathBuf::from)
    );
    picker.set_view(FileView::Tree);
    assert_eq!(selected_path(&picker), Path::new("src"));
    assert_eq!(paths(&picker), open);
    picker.left();
    picker.toggle_view();
    picker.navigate(true);
    assert_eq!(selected_path(&picker), Path::new("src/b.txt"));
    picker.toggle_view();
    assert_eq!(selected_path(&picker), Path::new("src/b.txt"));
    assert!(picker.entries().next().unwrap().expanded);
    picker.left();
    picker.toggle_view();
    picker.toggle_view();
    assert_eq!(selected_path(&picker), Path::new("src"));
}

#[test]
fn filtering_and_refresh_preserve_raw_selection_and_surviving_expansion() {
    let directory = Directory::new();
    directory.put("src/a.txt", "");
    directory.put("src/b.txt", "");
    directory.put("z.txt", "");
    let mut picker = directory.scan();
    select(&mut picker, "src/b.txt");
    picker.query = "absent".into();
    picker.refilter();
    assert_eq!(picker.entries().len(), 0);
    picker.query.clear();
    picker.refilter();
    assert_eq!(selected_path(&picker), Path::new("src/b.txt"));
    picker.set_view(FileView::Tree);
    assert_eq!(selected_path(&picker), Path::new("src/b.txt"));
    fs::remove_file(directory.0.join("src/b.txt")).unwrap();
    directory.put("src/c.txt", "");
    picker.refresh();
    assert_eq!(selected_path(&picker), Path::new("src"));
    assert!(picker.entries().next().unwrap().expanded);
    assert!(paths(&picker).contains(&PathBuf::from("src/c.txt")));
    fs::remove_dir_all(directory.0.join("src")).unwrap();
    picker.refresh();
    assert_eq!(selected_path(&picker), Path::new("z.txt"));
    assert!(picker.expanded.is_empty());
    picker.toggle_view();
    picker.toggle_view();
    assert_eq!(selected_path(&picker), Path::new("z.txt"));
}

#[test]
fn tree_search_subfocus_and_expansion_survive_view_toggles_and_refresh() {
    let directory = Directory::new();
    directory.put("src/deep/a.txt", "");
    directory.put("src/other.txt", "");
    let mut picker = tree(&directory);
    picker.start_search();
    assert!(picker.searching);
    assert_eq!(picker.entries().len(), 4);
    assert!(picker.expanded.is_empty());
    picker.toggle_view();
    assert_eq!(picker.view, FileView::List);
    picker.toggle_view();
    assert!(picker.searching);
    assert!(picker.expanded.is_empty());
    picker.query = "a.txt".into();
    picker.refilter();
    assert_eq!(selected_path(&picker), Path::new("src/deep/a.txt"));
    picker.refresh();
    assert!(picker.searching);
    assert_eq!(selected_path(&picker), Path::new("src/deep/a.txt"));
    let filtered = paths(&picker);
    picker.finish_search();
    assert!(!picker.searching);
    assert_eq!(picker.query, "a.txt");
    assert_eq!(paths(&picker), filtered);
    assert_eq!(selected_path(&picker), Path::new("src/deep/a.txt"));
    assert!(picker.expanded.is_empty());
    picker.toggle_view();
    picker.refresh();
    picker.toggle_view();
    assert!(!picker.searching);
    assert_eq!(picker.query, "a.txt");
    assert_eq!(selected_path(&picker), Path::new("src/deep/a.txt"));
    picker.start_search();
    assert!(picker.searching);
    assert_eq!(picker.query, "a.txt");
    assert_eq!(selected_path(&picker), Path::new("src/deep/a.txt"));
}

#[test]
fn clearing_filter_preserves_mode_focus_current_path_and_empty_result_fallback() {
    let directory = Directory::new();
    directory.put("src/deep/needle.txt", "");
    directory.put("src/other.txt", "");
    directory.put("other/keep.txt", "");
    for (view, searching) in [
        (FileView::Tree, false),
        (FileView::Tree, true),
        (FileView::List, false),
    ] {
        let mut picker = tree(&directory);
        select(&mut picker, "other");
        picker.right();
        let expanded = picker.expanded.clone();
        picker.set_view(view);
        if view == FileView::Tree {
            picker.start_search();
        }
        picker.query = "needle".into();
        picker.refilter();
        if !searching && view == FileView::Tree {
            picker.finish_search();
        }
        let expected = Path::new("src/deep/needle.txt");
        assert_eq!(selected_path(&picker), expected);
        picker.clear_filter();
        assert!(picker.query.is_empty());
        assert_eq!(picker.searching, searching);
        assert!(picker.focused);
        assert_eq!(selected_path(&picker), expected);
        assert!(picker.expanded.is_superset(&expanded));
        assert!(paths(&picker).contains(&PathBuf::from("other/keep.txt")));
        let rows = paths(&picker);
        let expanded = picker.expanded.clone();
        picker.clear_filter();
        assert_eq!(paths(&picker), rows);
        assert_eq!(picker.expanded, expanded);
        assert_eq!(selected_path(&picker), expected);
        assert_eq!(picker.searching, searching);

        picker.query = "absent".into();
        picker.refilter();
        picker.navigate(true);
        picker.navigate(false);
        assert!(picker.rows.is_empty());
        picker.refresh();
        assert!(picker.rows.is_empty());
        picker.clear_filter();
        assert_eq!(selected_path(&picker), expected);
        assert_eq!(picker.searching, searching);
        assert!(picker.focused);
    }

    let empty = Directory::new();
    let mut picker = tree(&empty);
    picker.start_search();
    picker.query = "absent".into();
    picker.refilter();
    picker.finish_search();
    picker.clear_filter();
    assert!(picker.rows.is_empty());
    assert_eq!(picker.selected, 0);
    assert!(!picker.searching);
    assert!(picker.focused);
}

#[test]
fn filtered_navigation_toggles_context_folders_and_query_edits_reveal_matches() {
    let directory = Directory::new();
    directory.put("src/deep/needle.txt", "");
    directory.put("src/other.txt", "");
    let mut picker = tree(&directory);
    picker.start_search();
    picker.query = "needle".into();
    picker.refilter();
    let expanded = picker.expanded.clone();
    picker.left();
    assert_eq!(selected_path(&picker), Path::new("src/deep"));
    picker.right();
    assert_eq!(selected_path(&picker), Path::new("src/deep/needle.txt"));
    assert_eq!(picker.expanded, expanded);
    picker.finish_search();
    picker.left();
    picker.left();
    assert_eq!(selected_path(&picker), Path::new("src/deep"));
    assert!(!picker.entries().nth(picker.selected).unwrap().expanded);
    assert_eq!(picker.query, "needle");
    assert!(!paths(&picker).contains(&PathBuf::from("src/deep/needle.txt")));
    picker.start_search();
    picker.finish_search();
    assert_eq!(selected_path(&picker), Path::new("src/deep"));
    assert!(!picker.entries().nth(picker.selected).unwrap().expanded);
    picker.right();
    assert!(picker.entries().nth(picker.selected).unwrap().expanded);
    picker.right();
    assert_eq!(selected_path(&picker), Path::new("src/deep/needle.txt"));
    picker.left();
    assert!(picker.accept().is_none());
    assert!(!picker.entries().nth(picker.selected).unwrap().expanded);
    assert!(picker.accept().is_none());
    assert!(picker.entries().nth(picker.selected).unwrap().expanded);
    picker.start_search();
    assert!(picker.accept().is_none());
    assert!(!picker.searching);
    assert_eq!(picker.query, "needle");
    assert_eq!(selected_path(&picker), Path::new("src/deep"));
    assert!(!picker.entries().nth(picker.selected).unwrap().expanded);
    picker.start_search();
    picker.query.push_str(".txt");
    picker.refilter();
    assert!(picker.filter_collapsed.is_empty());
    assert_eq!(selected_path(&picker), Path::new("src/deep/needle.txt"));
    picker.query.clear();
    picker.refilter();
    picker.finish_search();
    assert_eq!(selected_path(&picker), Path::new("src/deep/needle.txt"));
}

#[test]
fn filtered_collapse_survives_refresh_compaction_and_view_switching_by_raw_path() {
    let directory = Directory::new();
    directory.put("one/a.txt", "");
    directory.put("one/two/needle.txt", "");
    let mut picker = tree(&directory);
    picker.start_search();
    picker.query = "needle".into();
    picker.refilter();
    picker.finish_search();
    picker.left();
    picker.left();
    picker.left();
    picker.left();
    assert_eq!(selected_path(&picker), Path::new("one"));
    assert_eq!(paths(&picker), [PathBuf::from("one")]);
    picker.toggle_view();
    assert_eq!(selected_path(&picker), Path::new("one/two/needle.txt"));
    picker.toggle_view();
    assert_eq!(paths(&picker), [PathBuf::from("one")]);
    assert!(!picker.searching);
    fs::remove_file(directory.0.join("one/a.txt")).unwrap();
    picker.focused = false;
    picker.refresh();
    assert_eq!(selected_path(&picker), Path::new("one/two"));
    assert_eq!(paths(&picker), [PathBuf::from("one/two")]);
    assert!(!picker.searching && !picker.focused);
    assert_eq!(picker.query, "needle");
    directory.put("one/a.txt", "");
    picker.refresh();
    assert_eq!(selected_path(&picker), Path::new("one"));
    assert_eq!(paths(&picker), [PathBuf::from("one")]);
    picker.right();
    picker.right();
    assert_eq!(selected_path(&picker), Path::new("one/two"));
    assert!(!picker.entries().nth(picker.selected).unwrap().expanded);
    picker.right();
    assert!(picker.entries().nth(picker.selected).unwrap().expanded);
    picker.right();
    assert_eq!(selected_path(&picker), Path::new("one/two/needle.txt"));
    fs::remove_file(directory.0.join("one/two/needle.txt")).unwrap();
    picker.refresh();
    assert!(picker.entries().len() == 0);
    picker.clear_filter();
    assert_eq!(selected_path(&picker), Path::new("one/two"));
    assert!(!picker.searching && !picker.focused);
}

#[test]
fn refresh_preserves_expansion_when_directory_chains_merge_and_split() {
    let directory = Directory::new();
    directory.put("one/a.txt", "");
    directory.put("one/two/b.txt", "");
    let mut picker = tree(&directory);
    picker.right();
    assert_eq!(
        paths(&picker),
        ["one", "one/two", "one/a.txt"].map(PathBuf::from)
    );
    fs::remove_file(directory.0.join("one/a.txt")).unwrap();
    picker.refresh();
    assert_eq!(selected_path(&picker), Path::new("one/two"));
    assert_eq!(
        paths(&picker),
        ["one/two", "one/two/b.txt"].map(PathBuf::from)
    );
    assert!(picker.entries().next().unwrap().expanded);
    directory.put("one/a.txt", "");
    picker.refresh();
    assert_eq!(selected_path(&picker), Path::new("one/two"));
    assert_eq!(
        paths(&picker),
        ["one", "one/two", "one/a.txt"].map(PathBuf::from)
    );
    assert!(picker.entries().next().unwrap().expanded);
    assert!(!picker.entries().nth(1).unwrap().expanded);
    fs::remove_file(directory.0.join("one/a.txt")).unwrap();
    picker.refresh();
    picker.left();
    assert_eq!(paths(&picker), [PathBuf::from("one/two")]);
    directory.put("one/a.txt", "");
    picker.refresh();
    assert_eq!(paths(&picker), [PathBuf::from("one")]);
    assert!(!picker.entries().next().unwrap().expanded);
}