kimun_notes/components/

sidebar.rs

use std::sync::Arc;

use crate::settings::themes::Theme;
use async_trait::async_trait;
use chrono::NaiveDate;
use futures::StreamExt;
use kimun_core::nfs::VaultPath;
use kimun_core::{NoteVault, NotesValidation, ResultType, VaultBrowseOptionsBuilder};
use ratatui::Frame;
use ratatui::layout::{Constraint, Direction, Layout, Position, Rect};
use ratatui::style::Style;
use ratatui::text::{Line, Span};
use ratatui::widgets::{Block, Borders, Paragraph};

use crate::components::Component;
use crate::components::event_state::EventState;
use crate::components::events::{
    AppEvent, AppTx, AppTxExt, FileOp, InputEvent, SortTarget, redraw_callback,
};
use crate::components::file_list::{FileListEntry, SortField, SortOrder, entry_order};
use crate::components::search_list::{
    Emit, Filter, KeyReaction, OrderFn, RowSource, SearchList, SearchMouse,
};
use crate::components::sortable::{
    PropertySort, SortState, SortableList, is_blank_property, property_key,
};
use crate::keys::KeyBindings;
use crate::settings::AppSettings;
use crate::settings::icons::Icons;

/// Streamed `RowSource` over one directory's listing. Pushes an `Up` row first
/// (when not at root) so it is always present, then forwards each entry the
/// moment `browse_vault_stream` yields it — rows show up while a slow drive is
/// still being read. Ordering is the engine's job (`order_by`, see
/// [`listing_order`]), so nothing is re-delivered at the end. Loads once; a
/// local `Filter::Fuzzy` narrows the set and `leading_row` provides the
/// "Create: …" affordance.
struct DirListingSource {
    vault: Arc<NoteVault>,
    dir: VaultPath,
}

#[async_trait]
impl RowSource<FileListEntry> for DirListingSource {
    async fn load(&self, _query: &str, emit: Emit<FileListEntry>) {
        // Up row first (if not root) — pushed so it's always present.
        if !self.dir.is_root_or_empty() {
            emit.push(FileListEntry::Up {
                parent: self.dir.get_parent_path().0,
            });
        }

        let options = VaultBrowseOptionsBuilder::new(&self.dir)
            .recursive(false)
            .validation(NotesValidation::Full)
            .build();

        let mut stream = std::pin::pin!(self.vault.browse_vault_stream(options));
        while let Some(item) = stream.next().await {
            let result = match item {
                Ok(result) => result,
                Err(e) => {
                    tracing::warn!("sidebar directory listing failed: {e}");
                    break;
                }
            };
            // `is_like` ignores relative/absolute form: skip the current dir's
            // own "." entry whichever form each side carries.
            if matches!(result.rtype, ResultType::Directory) && result.path.is_like(&self.dir) {
                continue;
            }
            let journal_date = self
                .vault
                .journal_date(&result.path)
                .map(format_journal_date);
            emit.push(FileListEntry::from_result(result, journal_date));
        }
        emit.done();
    }

    fn leading_row(&self, query: &str) -> Option<FileListEntry> {
        if query.is_empty() {
            None
        } else {
            let path = self.dir.append(&VaultPath::note_path_from(query)).flatten();
            Some(FileListEntry::CreateNote {
                filename: path.to_string(),
                path,
            })
        }
    }

    fn reload_on_query(&self) -> bool {
        // Load the directory once; the local fuzzy filter narrows it and
        // `leading_row` keeps the create affordance in sync per keystroke.
        false
    }
}

pub struct SidebarComponent {
    current_dir: VaultPath,
    /// The note currently open in the editor, if any — drives the open-note
    /// marker. `None` on the Browse screen (it never opens notes). Matched
    /// against `FileListEntry::Note` rows by `is_like`.
    open_note: Option<VaultPath>,
    list: Option<SearchList<FileListEntry>>,
    vault: Arc<NoteVault>,
    icons: Icons,
    default_sort_field: SortField,
    default_sort_order: SortOrder,
    journal_sort_field: SortField,
    journal_sort_order: SortOrder,
    /// Sort field/order of the active listing. Set per `navigate` from the
    /// per-dir defaults (kept across a refresh of the same directory); the
    /// sort dialog changes it via `apply_sort`, which hands the engine a new
    /// order.
    sort: (SortField, SortOrder),
    /// Index values a property sort orders by, fetched per key.
    property_sort: PropertySort,
    /// "Group directories first" for the active listing; see `sort`.
    group_dirs: bool,
    rendered_rect: Rect,
    /// Screen cell each breadcrumb segment was drawn into on the last render,
    /// with the directory it navigates to — clickable breadcrumb hit-test.
    breadcrumb_cells: Vec<(Rect, VaultPath)>,
    /// The sort chip (`Name ↑`) on the search box border from the last render.
    sort_chip: crate::components::clickable::BorderChip,
    /// Whether to draw the sort chip at all — off where the host cannot open
    /// the sort dialog (Browse).
    show_sort_chip: bool,
    key_bindings: KeyBindings,
}

impl SidebarComponent {
    /// Build a sidebar from the application settings, pulling its key bindings
    /// and icons from `settings`. The shared constructor for the screens that
    /// host a sidebar (Editor and Browse), so the kb/icons wiring lives once.
    pub fn from_settings(vault: Arc<NoteVault>, settings: &AppSettings) -> Self {
        Self::new(
            settings.key_bindings.clone(),
            vault,
            settings.icons(),
            settings,
        )
    }

    pub fn new(
        key_bindings: KeyBindings,
        vault: Arc<NoteVault>,
        icons: Icons,
        settings: &AppSettings,
    ) -> Self {
        let default_sort_field = SortField::from(settings.default_sort_field);
        let default_sort_order = SortOrder::from(settings.default_sort_order);
        Self {
            current_dir: VaultPath::root(),
            open_note: None,
            list: None,
            vault,
            icons,
            default_sort_field: default_sort_field.clone(),
            default_sort_order,
            journal_sort_field: SortField::from(settings.journal_sort_field),
            journal_sort_order: SortOrder::from(settings.journal_sort_order),
            sort: (default_sort_field, default_sort_order),
            property_sort: PropertySort::default(),
            group_dirs: settings.group_directories,
            rendered_rect: Rect::default(),
            breadcrumb_cells: Vec::new(),
            sort_chip: Default::default(),
            show_sort_chip: true,
            key_bindings,
        }
    }

    /// The breadcrumb segment under the given screen cell, if any.
    fn breadcrumb_at(&self, column: u16, row: u16) -> Option<&VaultPath> {
        self.breadcrumb_cells
            .iter()
            .find(|(rect, _)| rect.contains(Position { x: column, y: row }))
            .map(|(_, dir)| dir)
    }

    pub fn current_dir(&self) -> &VaultPath {
        &self.current_dir
    }

    /// `true` until a directory has been loaded (no engine yet). The editor
    /// uses this to decide whether to issue the first-open navigation.
    pub fn is_empty(&self) -> bool {
        self.list.is_none()
    }

    /// Sort field/order to apply for `dir` (journal dirs get their own).
    fn sort_for(&self, dir: &VaultPath) -> (SortField, SortOrder) {
        if dir.is_like(self.vault.journal_path()) {
            (self.journal_sort_field.clone(), self.journal_sort_order)
        } else {
            (self.default_sort_field.clone(), self.default_sort_order)
        }
    }

    /// (Re)build the engine for `dir`, replacing any prior listing. This is the
    /// single directory-navigation entry point: changing directory = rebuild
    /// the engine with a fresh `DirListingSource` for the new dir, sorted by
    /// that directory's default.
    pub fn navigate(&mut self, dir: VaultPath, tx: &AppTx) {
        self.sort = self.sort_for(&dir);
        self.current_dir = dir;
        self.build_listing(tx);
    }

    /// A fresh engine over `current_dir`, ordered by the active sort. A
    /// property sort uses the values cached for its key and fetches them
    /// again, so edits since the last fetch show up.
    fn build_listing(&mut self, tx: &AppTx) {
        let source = DirListingSource {
            vault: self.vault.clone(),
            dir: self.current_dir.clone(),
        };
        self.list = Some(
            SearchList::builder(source, redraw_callback(tx.clone()))
                .filter(Filter::Fuzzy)
                .order_by(self.order())
                .yank_combos_from(&self.key_bindings)
                .icons(self.icons.clone())
                .build(),
        );
        self.fetch_property_values(tx);
    }

    /// Start a fetch of the active property sort's values, if it is one;
    /// any other sort forgets the cached values.
    fn fetch_property_values(&mut self, tx: &AppTx) {
        match property_key(&self.sort.0) {
            Some(key) => self.property_sort.fetch(&self.vault, key, tx),
            None => self.property_sort.clear(),
        }
    }

    /// The engine order for the active sort. A property sort whose values
    /// have not arrived yet orders by name (see [`entry_order`]).
    fn order(&self) -> OrderFn<FileListEntry> {
        let (field, order) = self.sort.clone();
        let values = self.property_sort.values_for_field(&field);
        entry_order(field, order, self.group_dirs, values)
    }

    /// Re-sort the loaded rows by the active sort (no reload). A property
    /// sort still waiting for its values keeps the current order.
    fn reorder(&mut self) {
        if self.property_sort.is_awaiting(&self.sort.0) {
            return;
        }
        let order = self.order();
        if let Some(list) = &mut self.list {
            list.set_order(Some(order));
        }
    }

    /// Property values fetched for `key` landed: re-sort if they belong to
    /// the active sort. `false` when they are stale and were dropped.
    pub(crate) fn on_property_sort_values(
        &mut self,
        key: &str,
        values: crate::components::file_list::PropertyValues,
    ) -> bool {
        let accepted = self.property_sort.receive(key, values);
        if accepted {
            self.reorder();
        }
        accepted
    }

    /// Apply property values that arrived since the last frame.
    fn poll_property_sort(&mut self) {
        if let Some((key, values)) = self.property_sort.poll() {
            self.on_property_sort_values(&key, values);
        }
    }

    /// Rebuild the listing only when it is currently showing `dir`, so a
    /// create/rename/delete/move in that directory is reflected without yanking
    /// the user away from an unrelated directory they browsed to. The active
    /// sort is kept (a property sort refetches its values). A no-op
    /// otherwise. Shared by every screen that hosts a sidebar.
    pub fn refresh_if_showing(&mut self, dir: &VaultPath, tx: &AppTx) {
        if dir.is_like(&self.current_dir) {
            self.build_listing(tx);
        }
    }

    /// Set (or clear) the note the editor currently has open, then re-stamp the
    /// marker on the live rows. The editor calls this on every open and on an
    /// open-note rename.
    pub fn set_open_note(&mut self, path: Option<VaultPath>) {
        self.open_note = path;
        self.stamp_open_marker();
    }

    /// Re-apply `is_open` to the rows so exactly the open note's row is marked.
    /// Idempotent: a full reload rebuilds rows without the flag, so this runs
    /// again after each load (see `render`).
    fn stamp_open_marker(&mut self) {
        let open = self.open_note.clone();
        if let Some(list) = &mut self.list {
            list.update_rows(|row| {
                if let FileListEntry::Note { path, is_open, .. } = row {
                    let want = open.as_ref().is_some_and(|o| path.is_like(o));
                    if *is_open != want {
                        *is_open = want;
                        return true;
                    }
                }
                false
            });
        }
    }

    /// Update the title of the row whose note path matches `path`, if it is in
    /// the current listing. Called when a note is saved and its title (first
    /// body line) may have changed. Position is left unchanged (no re-sort).
    pub fn update_note_row(&mut self, path: &VaultPath, new_title: &str) {
        if let Some(list) = &mut self.list {
            list.update_rows(|row| {
                if let FileListEntry::Note {
                    path: row_path,
                    title,
                    ..
                } = row
                    && row_path.is_like(path)
                    && title != new_title
                {
                    *title = new_title.to_string();
                    return true;
                }
                false
            });
        }
    }

    /// Move the row at `from` to `to` (path + filename + journal_date) in
    /// place, for a same-directory note rename. The row is re-sorted into its
    /// new spot under the active `listing_order` (a Name sort reads the very
    /// field this changes) and keeps the highlight if it had it.
    /// `journal_date` is recomputed so a rename into/out of a
    /// `YYYY-MM-DD` name under the journal directory flips the glyph and the
    /// secondary date line correctly.
    pub fn rename_note_row(&mut self, from: &VaultPath, to: &VaultPath) {
        let new_filename = to.get_parent_path().1;
        let new_journal_date = self.vault.journal_date(to).map(format_journal_date);
        if let Some(list) = &mut self.list {
            list.update_rows(|row| {
                if let FileListEntry::Note {
                    path,
                    filename,
                    journal_date,
                    ..
                } = row
                    && path.is_like(from)
                {
                    *path = to.clone();
                    *filename = new_filename.clone();
                    *journal_date = new_journal_date.clone();
                    return true;
                }
                false
            });
        }
    }

    /// Draw (and accept clicks on) the sort chip — on by default; off for a
    /// host that cannot open the sort dialog.
    pub fn set_sort_chip(&mut self, show: bool) {
        self.show_sort_chip = show;
    }

    /// Seed the directory the sidebar will show before its first `navigate`.
    /// Lets a screen open at a non-root path while keeping `current_dir` the
    /// single source of truth for the browsed directory.
    pub fn set_current_dir(&mut self, dir: VaultPath) {
        self.current_dir = dir;
    }

    /// Current sort field/order for the active listing.
    pub fn current_sort(&self) -> (SortField, SortOrder) {
        self.sort.clone()
    }

    /// Current "group directories first" flag.
    pub fn group_dirs(&self) -> bool {
        self.group_dirs
    }

    /// Apply a sort selection from the sort dialog: the engine re-orders the
    /// rows it already holds — no second walk of the directory. A property
    /// sort orders by the values cached for its key; without them the current
    /// order stays until they arrive (see [`SortableList::apply_sort`]).
    pub fn apply_sort(&mut self, field: SortField, order: SortOrder, group_dirs: bool) {
        self.sort = (field, order);
        self.group_dirs = group_dirs;
        self.reorder();
    }

    /// `true` when the active directory is the journal (so its sort default is
    /// the journal one). Lets the caller persist to the matching settings.
    pub fn is_current_journal(&self) -> bool {
        self.current_dir.is_like(self.vault.journal_path())
    }

    /// Record `field` / `order` as the in-session default for the active
    /// context (journal vs. normal) without re-sorting — the sidebar's "save
    /// as default", for callers that already applied the sort. Without it the
    /// cached per-context defaults that `sort_for`/`navigate` read stay at
    /// their construction-time values until restart. Never called with a
    /// property sort (it can't be a default).
    pub fn remember_default(&mut self, field: SortField, order: SortOrder) {
        if self.is_current_journal() {
            self.journal_sort_field = field;
            self.journal_sort_order = order;
        } else {
            self.default_sort_field = field;
            self.default_sort_order = order;
        }
    }

    /// Number of note rows currently visible (excludes Up / dirs / create).
    fn note_count(&self) -> usize {
        match &self.list {
            None => 0,
            Some(list) => list
                .visible_rows()
                .iter()
                .filter(|e| matches!(e, FileListEntry::Note { .. }))
                .count(),
        }
    }

    /// Act on the selected row: Up/Note/Directory → `OpenPath` (directories and
    /// Up route back through the editor's navigate, rebuilding the engine);
    /// CreateNote → materialise the note, then open it.
    fn activate_selected_entry(&self, tx: &AppTx) {
        let Some(list) = &self.list else { return };
        let Some(entry) = list.selected_row() else {
            return;
        };
        match entry {
            FileListEntry::CreateNote { path, .. } => {
                let path = path.clone();
                let vault = Arc::clone(&self.vault);
                let tx2 = tx.clone();
                tokio::spawn(async move {
                    match vault.load_or_create_note(&path, None).await {
                        Ok((_, created)) => tx2.announce_and_open(path, created),
                        Err(e) => {
                            tracing::warn!("create note failed for {path}: {e}");
                        }
                    }
                });
            }
            FileListEntry::Attachment { path, .. } => {
                tx.send(AppEvent::OpenAttachment(path.clone())).ok();
            }
            other => {
                tx.send(AppEvent::open(other.path().clone())).ok();
            }
        }
    }
}

/// Format a `NaiveDate` as a human-readable string with day-of-week.
/// Example: "Wednesday, March 17, 2026"
fn format_journal_date(date: NaiveDate) -> String {
    date.format("%A, %B %-d, %Y").to_string()
}

impl SortableList for SidebarComponent {
    fn sort_state(&self) -> SortState {
        let (field, order) = self.current_sort();
        SortState {
            field,
            order,
            group_dirs: Some(self.group_dirs),
        }
    }

    /// A `None` group flag keeps the current grouping. A property sort on a
    /// new key fetches its values from the index and re-sorts when they
    /// land; on the same key (an Order / Group toggle) it reuses the cached
    /// values. One with no key yet is ignored.
    fn apply_sort(&mut self, state: &SortState, tx: &AppTx) {
        if is_blank_property(&state.field) {
            return;
        }
        let group_dirs = state.group_dirs.unwrap_or(self.group_dirs);
        SidebarComponent::apply_sort(self, state.field.clone(), state.order, group_dirs);
        self.property_sort.sync(&self.vault, &state.field, tx);
    }

    fn allows_property(&self) -> bool {
        true
    }
}

impl Component for SidebarComponent {
    fn handle_input(&mut self, event: &InputEvent, tx: &AppTx) -> EventState {
        if let InputEvent::Mouse(mouse) = event {
            let pos = Position {
                x: mouse.column,
                y: mouse.row,
            };
            if !self.rendered_rect.contains(pos) {
                return EventState::NotConsumed;
            }
            // A click on a breadcrumb segment jumps up the tree.
            if matches!(
                mouse.kind,
                ratatui::crossterm::event::MouseEventKind::Down(
                    ratatui::crossterm::event::MouseButton::Left
                )
            ) && let Some(dir) = self.breadcrumb_at(mouse.column, mouse.row)
            {
                tx.send(AppEvent::open(dir.clone())).ok();
                return EventState::Consumed;
            }
            // A click on the sort chip opens the sort dialog.
            if self.sort_chip.hit(mouse) {
                tx.send(AppEvent::OpenSortDialog(SortTarget::Sidebar)).ok();
                return EventState::Consumed;
            }
            // Click-to-focus is handled centrally by `PanelSet::handle_mouse`;
            // only the sidebar's internal behavior lives here. The engine
            // hit-tests the wheel against the recorded panel rect (the whole
            // sidebar — header and search box included) and clicks against
            // the list rect.
            if let Some(list) = &mut self.list {
                match list.handle_mouse(mouse) {
                    SearchMouse::Activated(_) | SearchMouse::DoubleClicked { repeat: false, .. } => {
                        self.activate_selected_entry(tx)
                    }
                    // Right-click on a file/dir row → context menu.
                    SearchMouse::Context(_) => {
                        if let Some(entry) = list.selected_row()
                            && !matches!(
                                entry,
                                FileListEntry::Up { .. } | FileListEntry::CreateNote { .. }
                            )
                        {
                            tx.send(AppEvent::FileOp(FileOp::ShowMenu(entry.path().clone())))
                                .ok();
                        }
                    }
                    // ContentScroll* are unreachable: this host records no
                    // content sub-region.
                    SearchMouse::Selected(_)
                    | SearchMouse::Scrolled
                    | SearchMouse::ContentScrollUp
                    | SearchMouse::ContentScrollDown
                    | SearchMouse::InputFocused
                    // A repeat double-click: its first press already activated.
                    | SearchMouse::DoubleClicked { repeat: true, .. }
                    | SearchMouse::Autocomplete { .. }
                    | SearchMouse::None => {}
                }
            }
            return EventState::Consumed;
        }

        if let InputEvent::Key(key) = event {
            if self.list.is_none() {
                return EventState::NotConsumed;
            }
            let reaction = self.list.as_mut().unwrap().handle_key(key);
            match reaction {
                KeyReaction::Submit => {
                    self.activate_selected_entry(tx);
                    EventState::Consumed
                }
                KeyReaction::Consumed | KeyReaction::Cancel => EventState::Consumed,
                KeyReaction::Yank(target) => {
                    crate::components::yank_row(target, tx);
                    EventState::Consumed
                }
                KeyReaction::Intercepted(_) | KeyReaction::ListVerb(_) | KeyReaction::Unhandled => {
                    EventState::NotConsumed
                }
            }
        } else {
            EventState::NotConsumed
        }
    }

    fn hint_shortcuts(&self) -> Vec<(String, String)> {
        use crate::keys::action_shortcuts::ActionShortcuts;

        crate::components::hints::hints_for(
            &self.key_bindings,
            &[
                (ActionShortcuts::FocusSidebar, "\u{2190} focus left"),
                (ActionShortcuts::FocusEditor, "focus right \u{2192}"),
                (ActionShortcuts::OpenSortDialog, "sort"),
            ],
        )
    }

    fn render(&mut self, f: &mut Frame, rect: Rect, theme: &Theme, focused: bool) {
        self.rendered_rect = rect;

        let rows = Layout::default()
            .direction(Direction::Vertical)
            .constraints([
                Constraint::Length(3),
                Constraint::Length(3),
                Constraint::Min(0),
            ])
            .split(rect);

        let border_style = theme.border_style(focused);

        let header = Block::default()
            .title(format!("─ Files · {} ", self.current_dir))
            .borders(Borders::ALL)
            .border_style(border_style)
            .style(theme.panel_style());
        let header_inner = header.inner(rows[0]);
        f.render_widget(header, rows[0]);

        // Clickable breadcrumb: one span per ancestor directory, separated by
        // " / ", with the note count right-aligned. Each segment's cell is
        // recorded for the click hit-test.
        self.breadcrumb_cells.clear();
        let seg_style = Style::default()
            .fg(theme.fg_secondary.to_ratatui())
            .bg(theme.bg_panel.to_ratatui());
        let sep_style = Style::default()
            .fg(theme.gray.to_ratatui())
            .bg(theme.bg_panel.to_ratatui());
        let mut spans: Vec<Span> = Vec::new();
        let mut x = header_inner.x;
        let mut push_segment =
            |spans: &mut Vec<Span>, x: &mut u16, label: String, dir: VaultPath| {
                let w = unicode_width::UnicodeWidthStr::width(label.as_str()) as u16;
                // Only record cells that are (at least partly) visible — the
                // Paragraph clips at the header edge, so fully clipped
                // segments must not be clickable.
                if *x < header_inner.right() {
                    let visible = w.min(header_inner.right() - *x);
                    let r = Rect::new(*x, header_inner.y, visible, 1);
                    crate::components::clickable::register(r);
                    self.breadcrumb_cells.push((r, dir));
                }
                spans.push(Span::styled(label, seg_style));
                *x += w;
            };
        push_segment(&mut spans, &mut x, "~".to_string(), VaultPath::root());
        let slices = self.current_dir.get_slices();
        let mut acc = String::new();
        for slice in &slices {
            spans.push(Span::styled(" / ", sep_style));
            x += 3;
            acc.push('/');
            acc.push_str(slice);
            push_segment(&mut spans, &mut x, slice.clone(), VaultPath::new(&acc));
        }
        let count = format!("{} notes", self.note_count());
        let used: u16 = x - header_inner.x;
        let pad = header_inner
            .width
            .saturating_sub(used)
            .saturating_sub(unicode_width::UnicodeWidthStr::width(count.as_str()) as u16);
        spans.push(Span::styled(" ".repeat(pad as usize), sep_style));
        spans.push(Span::styled(count, sep_style));
        f.render_widget(Paragraph::new(Line::from(spans)), header_inner);

        // The sort chip sits on the search box, next to what it orders.
        let mut search_block = Block::default().title(" Search");
        if self.show_sort_chip {
            let (field, order) = self.current_sort();
            search_block = self.sort_chip.place(
                search_block,
                rows[1],
                crate::components::clickable::Edge::Top,
                crate::components::sortable::sort_chip_line(&field, order, theme),
            );
        } else {
            self.sort_chip.hide();
        }
        let search_block = search_block
            .borders(Borders::ALL)
            .border_style(border_style)
            .style(theme.panel_style());
        let search_inner = search_block.inner(rows[1]);
        f.render_widget(search_block, rows[1]);

        let list_block = Block::default()
            .borders(Borders::ALL)
            .border_style(border_style)
            .style(theme.panel_style());
        let list_inner = list_block.inner(rows[2]);
        f.render_widget(list_block, rows[2]);

        // Poll the engine so a just-completed load's rows are applied, then
        // re-stamp the open-note marker (the reload rebuilt rows without it)
        // before the list renders.
        if let Some(list) = &mut self.list {
            list.poll();
        }
        self.poll_property_sort();
        self.stamp_open_marker();
        if let Some(list) = &mut self.list {
            list.render_query(f, search_inner, theme, focused);
            list.render(f, list_inner, theme, focused);
            // Record the rendered-items rect (block inner area) for mouse
            // hit-testing: the engine maps a click to `row - rect.y`, so row 0
            // is the first item. The panel rect (whole sidebar) lets the wheel
            // scroll from anywhere within the sidebar, not just over the list.
            list.set_list_rect(list_inner);
            list.set_panel_rect(rect);
        }
    }
}

#[cfg(test)]
impl SidebarComponent {
    pub(crate) fn poll_for_test(&mut self) {
        if let Some(list) = &mut self.list {
            list.poll();
        }
        self.poll_property_sort();
        self.stamp_open_marker();
    }

    pub(crate) fn is_loading_for_test(&self) -> bool {
        self.list.as_ref().is_some_and(|l| l.is_loading())
    }

    pub(crate) fn note_row_is_open_for_test(&self, name: &str) -> bool {
        self.list.as_ref().is_some_and(|l| {
            l.rows().iter().any(|r| {
                matches!(r, FileListEntry::Note { path, is_open, .. }
                    if path.get_name() == name && *is_open)
            })
        })
    }

    pub(crate) fn note_row_title_for_test(&self, name: &str) -> Option<String> {
        self.list.as_ref().and_then(|l| {
            l.rows().iter().find_map(|r| match r {
                FileListEntry::Note { path, title, .. } if path.get_name() == name => {
                    Some(title.clone())
                }
                _ => None,
            })
        })
    }

    pub(crate) fn note_row_journal_date_for_test(&self, path: &VaultPath) -> Option<String> {
        self.list.as_ref().and_then(|l| {
            l.rows().iter().find_map(|r| match r {
                FileListEntry::Note {
                    path: row_path,
                    journal_date,
                    ..
                } if row_path.is_like(path) => journal_date.clone(),
                _ => None,
            })
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::settings::AppSettings;
    use crate::test_support::{mouse_down_at, temp_vault};
    use ratatui::crossterm::event::{KeyModifiers, MouseEvent, MouseEventKind};
    use tokio::sync::mpsc::unbounded_channel;

    async fn make_sidebar() -> SidebarComponent {
        let vault = temp_vault("sidebar").await;
        vault.validate_and_init().await.unwrap();
        let settings = AppSettings::default();
        SidebarComponent::new(
            settings.key_bindings.clone(),
            vault,
            settings.icons(),
            &settings,
        )
    }

    /// Build a sidebar over `vault` after creating each named note at root.
    async fn sidebar_with_notes(prefix: &str, names: &[&str]) -> SidebarComponent {
        let vault = temp_vault(prefix).await;
        vault.validate_and_init().await.unwrap();
        for name in names {
            vault
                .create_note(&VaultPath::note_path_from(name), "body")
                .await
                .unwrap();
        }
        let settings = AppSettings::default();
        SidebarComponent::new(
            settings.key_bindings.clone(),
            vault,
            settings.icons(),
            &settings,
        )
    }

    /// Clicks anywhere in the sidebar bounds — header, search box, list — are
    /// consumed by the sidebar. (Click-to-focus itself is handled centrally by
    /// `PanelSet::handle_mouse`, not here.)
    #[tokio::test]
    async fn mouse_down_in_sidebar_bounds_is_consumed() {
        let mut sidebar = make_sidebar().await;
        sidebar.rendered_rect = Rect {
            x: 0,
            y: 3,
            width: 30,
            height: 20,
        };
        let (tx, _rx) = unbounded_channel();

        // Header (top-of-sidebar) area.
        assert_eq!(
            sidebar.handle_input(&mouse_down_at(5, 4), &tx),
            EventState::Consumed
        );
        // Search-box area (rows 6..9 within the sidebar layout).
        assert_eq!(
            sidebar.handle_input(&mouse_down_at(5, 7), &tx),
            EventState::Consumed
        );
        // Outside the sidebar bounds.
        assert_eq!(
            sidebar.handle_input(&mouse_down_at(40, 7), &tx),
            EventState::NotConsumed
        );
    }

    fn scroll_event_at(col: u16, row: u16, kind: MouseEventKind) -> InputEvent {
        InputEvent::Mouse(MouseEvent {
            kind,
            column: col,
            row,
            modifiers: KeyModifiers::NONE,
        })
    }

    /// Load the sidebar at the vault root, then poll the engine to idle so the
    /// streamed rows have arrived.
    async fn navigate_to_root(sidebar: &mut SidebarComponent, tx: &AppTx) {
        sidebar.navigate(VaultPath::root(), tx);
        // The streamed source awaits `browse_vault_stream`; give the background
        // work real time to land, polling the engine between waits.
        for _ in 0..50 {
            if let Some(list) = &mut sidebar.list {
                list.poll();
                if !list.is_loading() {
                    break;
                }
            }
            tokio::time::sleep(std::time::Duration::from_millis(5)).await;
        }
        if let Some(list) = &mut sidebar.list {
            list.poll();
        }
    }

    /// Two clicks on the same list row activate it: first selects, second sends
    /// `OpenPath` (or, for `CreateNote`, materialises the note then opens it).
    #[tokio::test(flavor = "multi_thread")]
    async fn mouse_double_click_on_list_row_sends_open_path() {
        let mut sidebar = sidebar_with_notes("sidebar-dbl", &["alpha"]).await;
        let (tx, mut rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;

        sidebar.rendered_rect = Rect {
            x: 0,
            y: 3,
            width: 30,
            height: 20,
        };
        // The engine records the rendered-items rect; clicks hit-test as
        // `row - rect.y`, so row 0 (y=9) is the first item.
        if let Some(list) = &mut sidebar.list {
            list.set_list_rect(Rect {
                x: 0,
                y: 9,
                width: 30,
                height: 14,
            });
        }

        // First click: in the list area, on the first row (rect.y) — selects.
        sidebar.handle_input(&mouse_down_at(5, 9), &tx);

        // Second click on the same row activates the entry.
        sidebar.handle_input(&mouse_down_at(5, 9), &tx);
        let mut events = Vec::new();
        while let Ok(evt) = rx.try_recv() {
            events.push(evt);
        }
        assert!(
            events
                .iter()
                .any(|e| matches!(e, AppEvent::OpenPath { path: p, .. } if p.to_string().contains("alpha"))),
            "expected OpenPath for the activated note, got {events:?}"
        );
    }

    /// Scroll wheel anywhere in the sidebar bounds scrolls the file list — even
    /// when the cursor is over the header or search box. The viewport moves and
    /// the selection is carried along (keeping its screen position), so with a
    /// 1-row viewport the selected row changes on the first scroll.
    #[tokio::test(flavor = "multi_thread")]
    async fn scroll_down_in_sidebar_bounds_scrolls_list() {
        let mut sidebar = sidebar_with_notes("sidebar-scroll", &["alpha", "beta"]).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;

        sidebar.rendered_rect = Rect {
            x: 0,
            y: 3,
            width: 30,
            height: 20,
        };
        // A 1-row viewport over 2 notes, so the list overflows and can scroll.
        // The panel rect covers the whole sidebar, so the wheel works from the
        // header/search box too.
        if let Some(list) = &mut sidebar.list {
            list.set_list_rect(Rect {
                x: 0,
                y: 9,
                width: 30,
                height: 1,
            });
            list.set_panel_rect(Rect {
                x: 0,
                y: 3,
                width: 30,
                height: 20,
            });
        }

        let first = sidebar
            .list
            .as_ref()
            .unwrap()
            .selected_row()
            .map(|e| e.path().to_string());

        // Scroll down with the cursor inside the sidebar header (not the list).
        let result = sidebar.handle_input(&scroll_event_at(5, 4, MouseEventKind::ScrollDown), &tx);
        assert_eq!(result, EventState::Consumed);
        let after = sidebar
            .list
            .as_ref()
            .unwrap()
            .selected_row()
            .map(|e| e.path().to_string());
        assert_ne!(
            first, after,
            "scroll-from-header should scroll the list, carrying the selection"
        );
    }

    #[tokio::test]
    async fn mouse_down_outside_sidebar_is_not_consumed() {
        let mut sidebar = make_sidebar().await;
        sidebar.rendered_rect = Rect {
            x: 0,
            y: 3,
            width: 30,
            height: 20,
        };
        let (tx, mut rx) = unbounded_channel();

        // Click to the right of the sidebar (in the editor area).
        let result = sidebar.handle_input(&mouse_down_at(50, 10), &tx);
        assert_eq!(result, EventState::NotConsumed);
        assert!(rx.try_recv().is_err());
    }

    /// Navigating loads the directory's notes via the streamed source.
    #[tokio::test(flavor = "multi_thread")]
    async fn navigate_loads_directory_notes() {
        let mut sidebar = sidebar_with_notes("sidebar-nav", &["hello"]).await;
        assert!(sidebar.is_empty());
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;
        assert!(!sidebar.is_empty());
        assert_eq!(sidebar.note_count(), 1);
    }

    /// Poll the (already-navigated) engine to idle so a reload's streamed rows
    /// have arrived.
    async fn poll_to_idle(sidebar: &mut SidebarComponent) {
        for _ in 0..50 {
            if let Some(list) = &mut sidebar.list {
                list.poll();
                if !list.is_loading() {
                    break;
                }
            }
            tokio::time::sleep(std::time::Duration::from_millis(5)).await;
        }
        if let Some(list) = &mut sidebar.list {
            list.poll();
        }
    }

    /// Names of the visible note rows, in display order.
    fn note_names(sidebar: &SidebarComponent) -> Vec<String> {
        sidebar
            .list
            .as_ref()
            .unwrap()
            .visible_rows()
            .iter()
            .filter_map(|e| match e {
                FileListEntry::Note { filename, .. } => Some(filename.clone()),
                _ => None,
            })
            .collect()
    }

    /// The directory listing streams each row the moment the walk yields it
    /// and nothing else: ordering is the engine's job (`order_by`), so there
    /// is no end-of-walk re-delivery to make rows jump.
    #[tokio::test(flavor = "multi_thread")]
    async fn listing_streams_each_row_then_done() {
        use crate::components::search_list::Loaded;

        let sidebar = sidebar_with_notes("sidebar-stream", &["charlie", "alpha", "bravo"]).await;
        let source = DirListingSource {
            vault: sidebar.vault.clone(),
            dir: VaultPath::root(),
        };
        let (emit, rx) = Emit::capture();

        source.load("", emit).await;

        let events: Vec<Loaded<FileListEntry>> = rx.try_iter().map(|(_, ev)| ev).collect();
        let pushed_notes = events
            .iter()
            .filter(|e| matches!(e, Loaded::Push(FileListEntry::Note { .. })))
            .count();
        assert_eq!(pushed_notes, 3, "each note is streamed as its own row");
        assert!(
            !events.iter().any(|e| matches!(e, Loaded::Replace(_))),
            "no whole-set re-delivery"
        );
        assert!(
            matches!(events.last(), Some(Loaded::Done)),
            "done closes the load"
        );
    }

    /// A sort change re-orders the rows already loaded; it must not walk the
    /// directory again.
    #[tokio::test(flavor = "multi_thread")]
    async fn apply_sort_reorders_without_reloading() {
        let mut sidebar =
            sidebar_with_notes("sidebar-resort", &["alpha", "bravo", "charlie"]).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;
        let before = note_names(&sidebar);
        assert_eq!(before.len(), 3, "expected three notes, got {before:?}");

        sidebar.apply_sort(SortField::Name, SortOrder::Descending, false);

        let list = sidebar.list.as_ref().unwrap();
        assert!(
            !list.is_loading(),
            "a sort change must not reload the listing"
        );
        assert_eq!(
            note_names(&sidebar),
            before.iter().rev().cloned().collect::<Vec<_>>(),
            "rows re-ordered in place"
        );
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn apply_sort_reverse_flips_listing_order() {
        let mut sidebar = sidebar_with_notes("sidebar-sort", &["alpha", "bravo", "charlie"]).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;
        let before = note_names(&sidebar);
        assert_eq!(before.len(), 3, "expected three notes, got {before:?}");
        sidebar.apply_sort(SortField::Name, SortOrder::Descending, false);
        poll_to_idle(&mut sidebar).await;
        let after = note_names(&sidebar);
        assert_eq!(
            after,
            before.iter().rev().cloned().collect::<Vec<_>>(),
            "descending order should reverse the listing"
        );
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn apply_sort_changes_field() {
        let mut sidebar = sidebar_with_notes("sidebar-cycle", &["alpha", "bravo"]).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;
        sidebar.apply_sort(SortField::Title, SortOrder::Ascending, false);
        poll_to_idle(&mut sidebar).await;
        assert_eq!(sidebar.current_sort().0, SortField::Title);
        assert_eq!(note_names(&sidebar).len(), 2, "notes survive the resort");
    }

    /// Build a sidebar over a vault with both notes and a subdirectory.
    async fn sidebar_with_notes_and_dir(prefix: &str) -> SidebarComponent {
        let vault = temp_vault(prefix).await;
        vault.validate_and_init().await.unwrap();
        vault
            .create_note(&VaultPath::note_path_from("alpha"), "body")
            .await
            .unwrap();
        vault
            .create_note(&VaultPath::note_path_from("z-dir/inner"), "body")
            .await
            .unwrap();
        let settings = AppSettings::default();
        SidebarComponent::new(
            settings.key_bindings.clone(),
            vault,
            settings.icons(),
            &settings,
        )
    }

    /// Kinds of the visible rows, in display order (excluding the Up row).
    fn row_kinds(sidebar: &SidebarComponent) -> Vec<&'static str> {
        sidebar
            .list
            .as_ref()
            .unwrap()
            .visible_rows()
            .iter()
            .filter_map(|e| match e {
                FileListEntry::Note { .. } => Some("note"),
                FileListEntry::Directory { .. } => Some("dir"),
                _ => None,
            })
            .collect()
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn group_dirs_puts_directories_first() {
        let mut sidebar = sidebar_with_notes_and_dir("sidebar-group").await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;
        assert_eq!(row_kinds(&sidebar), vec!["note", "dir"]);
        sidebar.apply_sort(SortField::Name, SortOrder::Ascending, true);
        poll_to_idle(&mut sidebar).await;
        assert_eq!(
            row_kinds(&sidebar),
            vec!["dir", "note"],
            "grouping must cluster directories first"
        );
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn apply_sort_updates_shared_state() {
        let mut sidebar = sidebar_with_notes("sidebar-apply", &["alpha", "bravo"]).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;
        sidebar.apply_sort(SortField::Title, SortOrder::Descending, false);
        poll_to_idle(&mut sidebar).await;
        assert_eq!(
            sidebar.current_sort(),
            (SortField::Title, SortOrder::Descending)
        );
        assert!(!sidebar.group_dirs());
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn set_open_note_stamps_matching_row() {
        let mut sb = sidebar_with_notes("sb-open", &["alpha", "beta"]).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sb, &tx).await;

        sb.set_open_note(Some(VaultPath::note_path_from("alpha")));
        assert!(
            sb.note_row_is_open_for_test("alpha.md"),
            "open note is marked"
        );
        assert!(
            !sb.note_row_is_open_for_test("beta.md"),
            "other note is not marked"
        );

        sb.set_open_note(Some(VaultPath::note_path_from("beta")));
        assert!(!sb.note_row_is_open_for_test("alpha.md"));
        assert!(sb.note_row_is_open_for_test("beta.md"));

        sb.set_open_note(None);
        assert!(!sb.note_row_is_open_for_test("beta.md"));
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn update_note_row_changes_title_in_place() {
        let mut sb = sidebar_with_notes("sb-title", &["alpha"]).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sb, &tx).await;

        sb.update_note_row(&VaultPath::note_path_from("alpha"), "Fresh Title");
        assert_eq!(
            sb.note_row_title_for_test("alpha.md").as_deref(),
            Some("Fresh Title")
        );
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn rename_note_row_updates_path_and_filename() {
        let mut sb = sidebar_with_notes("sb-rename", &["alpha"]).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sb, &tx).await;

        let to = VaultPath::note_path_from("gamma");
        let expected_filename = to.get_parent_path().1;
        sb.rename_note_row(&VaultPath::note_path_from("alpha"), &to);
        assert!(
            sb.note_row_title_for_test("gamma.md").is_some(),
            "row now at new name"
        );
        assert!(
            sb.note_row_title_for_test("alpha.md").is_none(),
            "old name gone"
        );
        // Also verify the filename field itself was updated to the new name.
        let renamed_filename = sb
            .list
            .as_ref()
            .unwrap()
            .rows()
            .iter()
            .find_map(|r| match r {
                FileListEntry::Note { path, filename, .. } if path.is_like(&to) => {
                    Some(filename.clone())
                }
                _ => None,
            });
        assert_eq!(
            renamed_filename.as_deref(),
            Some(expected_filename.as_str()),
            "filename field must be updated to the new name"
        );
    }

    /// Renaming a journal-dir note (`YYYY-MM-DD`) to a non-date name clears
    /// `journal_date` on the row so the glyph and secondary date line update.
    #[tokio::test(flavor = "multi_thread")]
    async fn rename_note_row_clears_journal_date_when_renamed_away_from_date_name() {
        // Build a vault and create a note inside the journal directory with a
        // valid YYYY-MM-DD name so `vault.journal_date` returns Some(_).
        let vault = crate::test_support::temp_vault("sb-jdate").await;
        vault.validate_and_init().await.unwrap();
        let journal_path = vault.journal_path().clone();
        let date_name = "2026-06-09";
        let from = journal_path
            .append(&VaultPath::note_path_from(date_name))
            .absolute();
        vault.create_note(&from, "journal body").await.unwrap();

        let settings = AppSettings::default();
        let mut sb = SidebarComponent::new(
            settings.key_bindings.clone(),
            vault,
            settings.icons(),
            &settings,
        );
        let (tx, _rx) = unbounded_channel();
        // Navigate to the journal directory (not root) so the note row is listed.
        sb.navigate(journal_path.clone(), &tx);
        for _ in 0..50 {
            sb.poll_for_test();
            if !sb.is_loading_for_test() {
                break;
            }
            tokio::time::sleep(std::time::Duration::from_millis(5)).await;
        }
        sb.poll_for_test();

        // Precondition: the journal row has a non-None `journal_date`.
        assert!(
            sb.note_row_journal_date_for_test(&from).is_some(),
            "journal note must have a journal_date before rename"
        );

        // Rename the note to a plain name (not a date) in the same directory.
        let to = journal_path
            .append(&VaultPath::note_path_from("meeting"))
            .absolute();
        sb.rename_note_row(&from, &to);

        // The row should now have journal_date = None.
        assert_eq!(
            sb.note_row_journal_date_for_test(&to),
            None,
            "journal_date must be cleared after renaming to a non-date name"
        );
    }

    /// Regression: saving a default must survive navigation.
    /// `remember_default` updates the cached per-context default that
    /// `sort_for`/`navigate` read; without it, navigating re-derives the
    /// construction-time default and the saved choice is silently lost.
    #[tokio::test(flavor = "multi_thread")]
    async fn save_default_survives_navigation() {
        let mut sidebar = sidebar_with_notes("sidebar-savedef", &["alpha", "bravo"]).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;

        sidebar.remember_default(SortField::Title, SortOrder::Descending);
        sidebar.apply_sort(SortField::Title, SortOrder::Descending, false);
        poll_to_idle(&mut sidebar).await;

        // Re-navigate (root is non-journal) — sort_for must now yield the saved
        // default, not the constructor-time (Name, Ascending).
        sidebar.navigate(VaultPath::root(), &tx);
        poll_to_idle(&mut sidebar).await;
        assert_eq!(
            sidebar.current_sort(),
            (SortField::Title, SortOrder::Descending),
            "saved default must persist across navigation"
        );
    }

    /// A sidebar over notes with the given frontmatter bodies, at root.
    async fn sidebar_with_bodies(prefix: &str, notes: &[(&str, &str)]) -> SidebarComponent {
        let vault = temp_vault(prefix).await;
        vault.validate_and_init().await.unwrap();
        for (name, body) in notes {
            vault
                .create_note(&VaultPath::note_path_from(name), body)
                .await
                .unwrap();
        }
        let settings = AppSettings::default();
        SidebarComponent::new(
            settings.key_bindings.clone(),
            vault,
            settings.icons(),
            &settings,
        )
    }

    const RANKED: [(&str, &str); 3] = [
        ("alpha", "---\nrank: 3\n---\nbody"),
        ("bravo", "---\nrank: 1\n---\nbody"),
        ("charlie", "body"),
    ];

    fn property_state(key: &str, order: SortOrder) -> SortState {
        SortState {
            field: SortField::Property(key.into()),
            order,
            group_dirs: Some(false),
        }
    }

    /// Poll until the property values for the active sort have landed.
    async fn poll_property_values(sidebar: &mut SidebarComponent) {
        for _ in 0..100 {
            sidebar.poll_for_test();
            if !sidebar.property_sort.is_pending() {
                return;
            }
            tokio::time::sleep(std::time::Duration::from_millis(5)).await;
        }
        panic!("property values never arrived");
    }

    /// A property sort keeps the current order until the values arrive, then
    /// re-sorts by them: valued notes first, the note without the key last.
    #[tokio::test(flavor = "multi_thread")]
    async fn property_sort_reorders_once_values_arrive() {
        let mut sidebar = sidebar_with_bodies("sidebar-prop", &RANKED).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;
        assert!(SortableList::allows_property(&sidebar));
        assert_eq!(note_names(&sidebar), ["alpha.md", "bravo.md", "charlie.md"]);

        SortableList::apply_sort(
            &mut sidebar,
            &property_state("Rank", SortOrder::Ascending),
            &tx,
        );
        assert_eq!(
            note_names(&sidebar),
            ["alpha.md", "bravo.md", "charlie.md"],
            "current order kept until the values arrive"
        );
        poll_property_values(&mut sidebar).await;
        assert_eq!(note_names(&sidebar), ["bravo.md", "alpha.md", "charlie.md"]);

        // Same key again: the cached values apply at once.
        SortableList::apply_sort(
            &mut sidebar,
            &property_state("Rank", SortOrder::Descending),
            &tx,
        );
        assert_eq!(note_names(&sidebar), ["alpha.md", "bravo.md", "charlie.md"]);
    }

    /// Values delivered for a key the sort no longer uses are dropped.
    #[tokio::test(flavor = "multi_thread")]
    async fn stale_property_values_are_ignored() {
        use kimun_core::PropertySortValue::Number;
        let mut sidebar = sidebar_with_bodies("sidebar-stale", &RANKED).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;
        SortableList::apply_sort(
            &mut sidebar,
            &property_state("rank", SortOrder::Ascending),
            &tx,
        );
        let stale = Arc::new(std::collections::HashMap::from([(
            VaultPath::note_path_from("/charlie"),
            Number(0.0),
        )]));
        assert!(!sidebar.on_property_sort_values("other", stale.clone()));
        assert_eq!(note_names(&sidebar), ["alpha.md", "bravo.md", "charlie.md"]);
        // The same map for the active key lands.
        assert!(sidebar.on_property_sort_values("rank", stale));
        assert_eq!(note_names(&sidebar), ["charlie.md", "alpha.md", "bravo.md"]);
    }

    /// A refresh of the shown directory keeps the property sort and fetches
    /// the values again, so an edited value moves its row.
    #[tokio::test(flavor = "multi_thread")]
    async fn refresh_keeps_the_property_sort_and_refetches() {
        let mut sidebar = sidebar_with_bodies("sidebar-prop-refresh", &RANKED).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;
        SortableList::apply_sort(
            &mut sidebar,
            &property_state("rank", SortOrder::Ascending),
            &tx,
        );
        poll_property_values(&mut sidebar).await;
        assert_eq!(note_names(&sidebar), ["bravo.md", "alpha.md", "charlie.md"]);

        sidebar
            .vault
            .save_note(
                &VaultPath::note_path_from("bravo"),
                "---\nrank: 9\n---\nbody",
            )
            .await
            .unwrap();
        sidebar.refresh_if_showing(&VaultPath::root(), &tx);
        poll_to_idle(&mut sidebar).await;
        poll_property_values(&mut sidebar).await;
        assert_eq!(
            sidebar.current_sort(),
            (SortField::Property("rank".into()), SortOrder::Ascending)
        );
        assert_eq!(note_names(&sidebar), ["alpha.md", "bravo.md", "charlie.md"]);
    }

    /// Order / Group toggles on the same property key reuse the cached
    /// values; a new key or a listing refresh fetches them again.
    #[tokio::test(flavor = "multi_thread")]
    async fn property_sort_toggles_reuse_the_cached_values() {
        let mut sidebar = sidebar_with_bodies("sidebar-prop-cache", &RANKED).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;
        SortableList::apply_sort(
            &mut sidebar,
            &property_state("rank", SortOrder::Ascending),
            &tx,
        );
        poll_property_values(&mut sidebar).await;
        let fetches = sidebar.property_sort.fetches;
        assert_eq!(fetches, 1);

        for order in [SortOrder::Descending, SortOrder::Ascending] {
            SortableList::apply_sort(&mut sidebar, &property_state("Rank", order), &tx);
        }
        let mut grouped = property_state("rank", SortOrder::Ascending);
        grouped.group_dirs = Some(true);
        SortableList::apply_sort(&mut sidebar, &grouped, &tx);
        assert_eq!(
            sidebar.property_sort.fetches, fetches,
            "toggles: no refetch"
        );
        assert!(!sidebar.property_sort.is_pending());
        assert_eq!(note_names(&sidebar), ["bravo.md", "alpha.md", "charlie.md"]);

        SortableList::apply_sort(
            &mut sidebar,
            &property_state("due", SortOrder::Ascending),
            &tx,
        );
        assert_eq!(
            sidebar.property_sort.fetches,
            fetches + 1,
            "new key fetches"
        );
        poll_property_values(&mut sidebar).await;

        sidebar.refresh_if_showing(&VaultPath::root(), &tx);
        assert_eq!(
            sidebar.property_sort.fetches,
            fetches + 2,
            "refresh refetches"
        );
        poll_to_idle(&mut sidebar).await;
        poll_property_values(&mut sidebar).await;
    }

    /// Leaving a property sort and coming back to the same key refetches:
    /// values edited meanwhile must show up.
    #[tokio::test(flavor = "multi_thread")]
    async fn returning_to_a_property_sort_refetches() {
        let mut sidebar = sidebar_with_bodies("sidebar-prop-return", &RANKED).await;
        let (tx, _rx) = unbounded_channel();
        navigate_to_root(&mut sidebar, &tx).await;
        SortableList::apply_sort(
            &mut sidebar,
            &property_state("rank", SortOrder::Ascending),
            &tx,
        );
        poll_property_values(&mut sidebar).await;
        assert_eq!(note_names(&sidebar), ["bravo.md", "alpha.md", "charlie.md"]);
        sidebar
            .vault
            .save_note(
                &VaultPath::note_path_from("bravo"),
                "---\nrank: 9\n---\nbody",
            )
            .await
            .unwrap();
        let mut name = property_state("rank", SortOrder::Ascending);
        name.field = SortField::Name;
        SortableList::apply_sort(&mut sidebar, &name, &tx);
        SortableList::apply_sort(
            &mut sidebar,
            &property_state("rank", SortOrder::Ascending),
            &tx,
        );
        assert_eq!(sidebar.property_sort.fetches, 2, "back to rank refetches");
        poll_property_values(&mut sidebar).await;
        assert_eq!(note_names(&sidebar), ["alpha.md", "bravo.md", "charlie.md"]);
    }

    // ── A slow filesystem: streamed rows on the test's schedule ──────────
    //
    // `DirListingSource` forwards each entry the moment `browse_vault_stream`
    // yields it, so on a slow drive the sidebar shows a PARTIAL listing for
    // many frames — and the user can sort, filter and select inside that
    // window while more rows keep landing. A real vault settles on the first
    // poll, so none of that window is reachable through `navigate_to_root`.
    // This source parks its `Emit` instead and lets the test say when each row
    // arrives, which is the only way to pin what the selection does across
    // LATER polls.

    struct SlowListingSource {
        slot: Arc<std::sync::Mutex<Option<Emit<FileListEntry>>>>,
    }

    #[async_trait]
    impl RowSource<FileListEntry> for SlowListingSource {
        async fn load(&self, _query: &str, emit: Emit<FileListEntry>) {
            *self.slot.lock().unwrap() = Some(emit);
        }
        fn reload_on_query(&self) -> bool {
            false
        }
    }

    /// The engine `navigate` builds — same filter and same `listing_order` —
    /// over a listing the test drives row by row.
    async fn slow_listing(
        field: SortField,
        order: SortOrder,
        group_dirs: bool,
    ) -> (SearchList<FileListEntry>, Emit<FileListEntry>) {
        let slot = Arc::new(std::sync::Mutex::new(None));
        let list = SearchList::builder(
            SlowListingSource { slot: slot.clone() },
            Arc::new(|| {}) as Arc<dyn Fn() + Send + Sync>,
        )
        .filter(Filter::Fuzzy)
        .order_by(entry_order(field, order, group_dirs, None))
        .build();
        let emit = loop {
            if let Some(e) = slot.lock().unwrap().clone() {
                break e;
            }
            tokio::task::yield_now().await;
        };
        (list, emit)
    }

    fn note_row(title: &str) -> FileListEntry {
        let path = VaultPath::note_path_from(title);
        let filename = path.get_parent_path().1;
        FileListEntry::Note {
            path,
            title: title.to_string(),
            filename,
            journal_date: None,
            is_open: false,
        }
    }

    fn dir_row(name: &str) -> FileListEntry {
        FileListEntry::Directory {
            path: VaultPath::new(name),
            name: name.to_string(),
        }
    }

    /// Row labels in display order. Avoids `sort_key`, which would put the
    /// note extension into every assertion.
    fn labels(list: &SearchList<FileListEntry>) -> Vec<String> {
        list.visible_rows().iter().map(|r| label(r)).collect()
    }

    fn label(row: &FileListEntry) -> String {
        match row {
            FileListEntry::Up { .. } => "..".to_string(),
            FileListEntry::Directory { name, .. } => format!("{name}/"),
            FileListEntry::Note { title, .. } => title.clone(),
            FileListEntry::Attachment { filename, .. } => filename.clone(),
            FileListEntry::CreateNote { filename, .. } => format!("create:{filename}"),
        }
    }

    fn highlighted(list: &SearchList<FileListEntry>) -> Option<String> {
        list.selected_row().map(label)
    }

    /// The baseline for a slow drive: until the user touches it, the highlight
    /// belongs to the TOP of the sort, not to whichever entry the walker
    /// happened to reach first. Every later poll re-decides it.
    #[tokio::test]
    async fn a_slow_listing_keeps_the_untouched_highlight_on_the_top_row() {
        let (mut list, emit) = slow_listing(SortField::Name, SortOrder::Ascending, false).await;

        emit.push(note_row("mike"));
        list.poll();
        assert_eq!(highlighted(&list).as_deref(), Some("mike"));

        emit.push(note_row("delta"));
        list.poll();
        assert_eq!(labels(&list), ["delta", "mike"]);
        assert_eq!(highlighted(&list).as_deref(), Some("delta"));

        emit.push(note_row("alpha"));
        list.poll();
        assert_eq!(labels(&list), ["alpha", "delta", "mike"]);
        assert_eq!(
            highlighted(&list).as_deref(),
            Some("alpha"),
            "the highlight follows the top of the sort, not the first row to arrive"
        );
        emit.done();
    }

    /// In a subdirectory the `Up` row is PUSHED (not a leading row) and is
    /// filter-exempt, so it is both the first row to arrive and the first in
    /// `listing_order`. The untouched highlight must sit on it and stay there
    /// as the directory's own entries trickle in.
    #[tokio::test]
    async fn a_slow_subdirectory_listing_keeps_the_highlight_on_the_up_row() {
        let (mut list, emit) = slow_listing(SortField::Name, SortOrder::Ascending, false).await;

        emit.push(FileListEntry::Up {
            parent: VaultPath::root(),
        });
        list.poll();
        assert_eq!(highlighted(&list).as_deref(), Some(".."));

        emit.push(note_row("alpha"));
        list.poll();
        emit.push(note_row("aaron")); // sorts above "alpha", but below `Up`
        list.poll();
        assert_eq!(labels(&list), ["..", "aaron", "alpha"]);
        assert_eq!(
            highlighted(&list).as_deref(),
            Some(".."),
            "`Up` outranks every arriving entry, so the seed never leaves it"
        );
        emit.done();
    }

    /// The sort dialog is reachable while the drive is still being read.
    /// Re-sorting an untouched listing must leave the highlight on the top of
    /// the NEW order — and must not silently promote the seed to a choice, so
    /// rows arriving afterwards still take the top with it.
    #[tokio::test]
    async fn a_sort_change_mid_stream_keeps_the_untouched_highlight_on_top() {
        let (mut list, emit) = slow_listing(SortField::Name, SortOrder::Ascending, false).await;

        emit.push(note_row("bravo"));
        emit.push(note_row("delta"));
        list.poll();
        assert_eq!(labels(&list), ["bravo", "delta"]);
        assert_eq!(highlighted(&list).as_deref(), Some("bravo"));

        // The user flips to descending while rows are still arriving.
        list.set_order(Some(entry_order(
            SortField::Name,
            SortOrder::Descending,
            false,
            None,
        )));
        assert_eq!(labels(&list), ["delta", "bravo"]);
        assert_eq!(
            highlighted(&list).as_deref(),
            Some("delta"),
            "a re-sort moves the untouched highlight to the new top row"
        );

        // ...and the rest of the slow listing keeps landing, still sorted,
        // still carrying the highlight.
        emit.push(note_row("echo"));
        list.poll();
        assert_eq!(labels(&list), ["echo", "delta", "bravo"]);
        assert_eq!(
            highlighted(&list).as_deref(),
            Some("echo"),
            "the sort change must not turn the seed into a user choice"
        );
        emit.done();
    }

    /// The chosen half of the same window: a row the user picked mid-stream is
    /// theirs. A re-sort and every later arrival move it around the list, and
    /// it stays highlighted throughout.
    #[tokio::test]
    async fn a_row_chosen_mid_stream_survives_a_sort_change_and_later_arrivals() {
        let (mut list, emit) = slow_listing(SortField::Name, SortOrder::Ascending, false).await;

        emit.push(note_row("bravo"));
        emit.push(note_row("delta"));
        list.poll();
        list.select_next(); // "delta", by the user's own keys
        assert_eq!(highlighted(&list).as_deref(), Some("delta"));

        list.set_order(Some(entry_order(
            SortField::Name,
            SortOrder::Descending,
            false,
            None,
        )));
        assert_eq!(labels(&list), ["delta", "bravo"]);
        assert_eq!(highlighted(&list).as_deref(), Some("delta"));

        emit.push(note_row("echo")); // sorts above it under the new order
        list.poll();
        assert_eq!(labels(&list), ["echo", "delta", "bravo"]);
        assert_eq!(
            highlighted(&list).as_deref(),
            Some("delta"),
            "a chosen row keeps the highlight through a re-sort and later arrivals"
        );
        emit.done();
    }

    /// `listing_order` ranks directories above notes when `group_dirs` is set,
    /// so a directory the walker reaches LAST still lands at the top — and
    /// takes an untouched highlight with it.
    #[tokio::test]
    async fn a_late_directory_takes_the_top_when_directories_are_grouped() {
        let (mut list, emit) = slow_listing(SortField::Name, SortOrder::Ascending, true).await;

        emit.push(note_row("alpha"));
        emit.push(note_row("bravo"));
        list.poll();
        assert_eq!(highlighted(&list).as_deref(), Some("alpha"));

        emit.push(dir_row("zeta"));
        list.poll();
        assert_eq!(labels(&list), ["zeta/", "alpha", "bravo"]);
        assert_eq!(
            highlighted(&list).as_deref(),
            Some("zeta/"),
            "grouped directories outrank notes whenever they arrive"
        );
        emit.done();
    }

    /// Typing narrows the partial listing locally (`reload_on_query` is false,
    /// so no reload). A row the user picked stays picked while the rest of the
    /// slow listing lands behind the filter.
    #[tokio::test]
    async fn filtering_mid_stream_keeps_a_chosen_row_while_more_rows_arrive() {
        let (mut list, emit) = slow_listing(SortField::Name, SortOrder::Ascending, false).await;

        emit.push(note_row("alpha"));
        emit.push(note_row("albatross"));
        emit.push(note_row("zebra"));
        list.poll();
        list.set_query("al");
        assert_eq!(labels(&list), ["albatross", "alpha"]);
        list.select_next(); // "alpha", chosen behind the filter
        assert_eq!(highlighted(&list).as_deref(), Some("alpha"));

        // More of the directory lands; one entry matches the filter and sorts
        // above the chosen row, the other is filtered out entirely.
        emit.push(note_row("alabama"));
        emit.push(note_row("yankee"));
        list.poll();
        assert_eq!(labels(&list), ["alabama", "albatross", "alpha"]);
        assert_eq!(
            highlighted(&list).as_deref(),
            Some("alpha"),
            "the chosen row keeps the highlight behind an active filter"
        );

        // Clearing the filter reveals the rest without losing the choice.
        list.set_query("");
        assert_eq!(
            labels(&list),
            ["alabama", "albatross", "alpha", "yankee", "zebra"]
        );
        assert_eq!(highlighted(&list).as_deref(), Some("alpha"));
        emit.done();
    }

    /// An in-place row update (the editor renaming the open note's title) is a
    /// recompute, and a recompute re-applies `order_by` — so under a Title sort
    /// the touched row MOVES. The highlight has to move with it: the user is
    /// pointing at a note, not at a slot.
    #[tokio::test]
    async fn an_in_place_update_that_re_sorts_carries_the_highlight_with_the_row() {
        let (mut list, emit) = slow_listing(SortField::Title, SortOrder::Ascending, false).await;
        emit.push(note_row("alpha"));
        emit.push(note_row("bravo"));
        emit.push(note_row("charlie"));
        list.poll();
        list.select_next();
        list.select_next();
        assert_eq!(highlighted(&list).as_deref(), Some("charlie"));

        // The editor retitles the selected note to something that sorts first.
        list.update_rows(|row| {
            if let FileListEntry::Note { title, .. } = row
                && title == "charlie"
            {
                *title = "aaa".to_string();
                return true;
            }
            false
        });

        assert_eq!(labels(&list), ["aaa", "alpha", "bravo"]);
        assert_eq!(
            highlighted(&list).as_deref(),
            Some("aaa"),
            "the highlight belongs to the row, not to the position it used to hold"
        );
        emit.done();
    }

    /// ...and the seeded half: an untouched highlight keeps the top slot when
    /// an in-place update re-sorts the listing under it.
    #[tokio::test]
    async fn an_in_place_update_that_re_sorts_leaves_a_seed_on_the_top_row() {
        let (mut list, emit) = slow_listing(SortField::Title, SortOrder::Ascending, false).await;
        emit.push(note_row("bravo"));
        emit.push(note_row("charlie"));
        list.poll();
        assert_eq!(highlighted(&list).as_deref(), Some("bravo"));

        list.update_rows(|row| {
            if let FileListEntry::Note { title, .. } = row
                && title == "charlie"
            {
                *title = "aaa".to_string();
                return true;
            }
            false
        });

        assert_eq!(labels(&list), ["aaa", "bravo"]);
        assert_eq!(
            highlighted(&list).as_deref(),
            Some("aaa"),
            "an untouched highlight belongs to the top of the order after any recompute"
        );
        emit.done();
    }
}