rootle 0.13.1

//! Find-in-file (`␣ /`, plans/0007 §3): the session state, the
//! occurrence scan, and the chip pass that restyles matched ranges
//! inside rendered lines. Chips render from `matches`; `n`/`N` move
//! `current` and the line cursor follows.

use super::Preview;
use ratatui::style::Style;
use ratatui::text::Line;

/// One find occurrence: 0-based line + byte range in that line's
/// plain (tab-expanded) text.
#[derive(Debug, Clone, Copy, PartialEq)]
pub(super) struct FindMatch {
    pub(super) line: usize,
    pub(super) start: usize,
    pub(super) end: usize,
}

/// Active find-in-file session (plans/0007 §3). Chips render from
/// `matches`; `n`/`N` move `current` and the line cursor follows.
pub(super) struct FindState {
    pub(super) query: String,
    pub(super) matches: Vec<FindMatch>,
    /// Index into `matches` the cursor sits on.
    pub(super) current: usize,
    /// Cursor line before the session — restored on cancel (vim `/`).
    pub(super) saved_cursor: usize,
}

/// Matching is shared with diff search and retains original UTF-8 byte ranges.
fn compute_matches(lines: &[String], query: &str) -> Vec<FindMatch> {
    let search = crate::components::text::LiteralSearch::new(query);
    lines
        .iter()
        .enumerate()
        .flat_map(|(line, text)| {
            search.ranges(text).into_iter().map(move |range| FindMatch {
                line,
                start: range.start,
                end: range.end,
            })
        })
        .collect()
}

impl Preview {
    /// Real text content supports find-in-file; dirs, binaries and
    /// meta placeholders don't.
    pub fn findable(&self) -> bool {
        self.numbered
    }

    pub fn find_active(&self) -> bool {
        self.find.is_some()
    }

    /// Open a find session (`␣ /`); the pre-find cursor is remembered
    /// for cancel.
    pub fn begin_find(&mut self) {
        if !self.findable() {
            return;
        }
        self.find = Some(FindState {
            query: String::new(),
            matches: vec![],
            current: 0,
            saved_cursor: self.cursor,
        });
    }

    /// Recompute matches on every FIND keystroke; the cursor lands on
    /// the first match at/after the session's start line (vim),
    /// wrapping to the top.
    pub fn update_find(&mut self, query: String) {
        if !self.findable() {
            return;
        }
        let saved_cursor = self
            .find
            .as_ref()
            .map(|f| f.saved_cursor)
            .unwrap_or(self.cursor);
        let matches = compute_matches(&self.plain_lines(), &query);
        let mut state = FindState {
            query,
            matches,
            current: 0,
            saved_cursor,
        };
        if !state.matches.is_empty() {
            let idx = state
                .matches
                .iter()
                .position(|m| m.line >= saved_cursor)
                .unwrap_or(0);
            state.current = idx;
            self.cursor = state.matches[idx].line;
        }
        self.find = Some(state);
    }

    /// Esc mid-session (FIND mode): restore the pre-find cursor, drop
    /// the chips — vim's cancelled `/`.
    pub fn cancel_find(&mut self) {
        if let Some(state) = self.find.take() {
            self.cursor = state.saved_cursor.min(self.line_count.saturating_sub(1));
        }
    }

    /// Esc in BROWSE with a committed find: clear the chips, keep the
    /// cursor (`:nohlsearch`).
    pub fn clear_find(&mut self) {
        self.find = None;
    }

    /// `n`/`N`: cycle matches with wraparound; the cursor follows.
    /// False when no session or no matches (key is a no-op).
    pub fn find_step(&mut self, delta: i32) -> bool {
        let Some(state) = &mut self.find else {
            return false;
        };
        if state.matches.is_empty() {
            return false;
        }
        let len = state.matches.len() as i32;
        let next = (state.current as i32 + delta).rem_euclid(len) as usize;
        state.current = next;
        self.cursor = state.matches[next].line;
        true
    }
}

/// Restyle match ranges inside a rendered line: spans split at range
/// boundaries, covered segments take the chip style, everything else
/// keeps its syntax styling. `ranges` are (start, end, is_current)
/// byte offsets into the line's plain text, sorted by start.
pub(super) fn chip_line(
    line: &Line<'static>,
    ranges: &[(usize, usize, bool)],
    match_style: Style,
    current_style: Style,
) -> Line<'static> {
    let overlays: Vec<_> = ranges
        .iter()
        .map(|(start, end, current)| {
            (
                *start..*end,
                if *current { current_style } else { match_style },
            )
        })
        .collect();
    crate::components::text::paint_line(line, crate::components::text::TextColumns::ALL, &overlays)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn findable_preview() -> Preview {
        let mut p = Preview::new();
        p.set_bytes(
            "main.rs",
            b"fn main() {}\nlet ratatui = 1;\nno match here\nratatui ratatui\n",
        );
        p
    }

    #[test]
    fn find_lands_on_first_match_at_or_after_cursor() {
        let mut p = findable_preview();
        p.begin_find();
        p.update_find("ratatui".into());
        assert_eq!(p.line(), Some(2)); // first match from line 1
        assert_eq!(
            p.readout().as_deref(),
            Some("1/3 · 2/4"),
            "three occurrences (two on line 4)"
        );
        // From a later cursor, the same query wraps-aware forward.
        let mut p = findable_preview();
        p.move_cursor(2); // line 3
        p.begin_find();
        p.update_find("ratatui".into());
        assert_eq!(p.line(), Some(4));
        assert_eq!(p.readout().as_deref(), Some("2/3 · 4/4"));
    }

    #[test]
    fn find_step_cycles_per_occurrence_with_wrap() {
        let mut p = findable_preview();
        p.begin_find();
        p.update_find("ratatui".into());
        assert!(p.find_step(1));
        assert_eq!(p.readout().as_deref(), Some("2/3 · 4/4"));
        assert!(p.find_step(1)); // second occurrence on line 4
        assert_eq!(p.readout().as_deref(), Some("3/3 · 4/4"));
        assert!(p.find_step(1)); // wraps to first
        assert_eq!(p.readout().as_deref(), Some("1/3 · 2/4"));
        assert!(p.find_step(-1)); // wraps back
        assert_eq!(p.readout().as_deref(), Some("3/3 · 4/4"));
    }

    #[test]
    fn find_no_match_keeps_cursor_and_shows_zero() {
        let mut p = findable_preview();
        p.move_cursor(1);
        p.begin_find();
        p.update_find("zzzz".into());
        assert_eq!(p.line(), Some(2));
        assert_eq!(p.readout().as_deref(), Some("0/0 · 2/4"));
        assert!(!p.find_step(1));
    }

    #[test]
    fn cancel_restores_cursor_clear_keeps_it() {
        let mut p = findable_preview();
        p.move_cursor(2); // line 3
        p.begin_find();
        p.update_find("ratatui".into());
        assert_eq!(p.line(), Some(4));
        p.cancel_find();
        assert_eq!(p.line(), Some(3), "cancel restores the pre-find line");
        assert!(!p.find_active());

        let mut p = findable_preview();
        p.begin_find();
        p.update_find("ratatui".into());
        p.clear_find(); // :nohlsearch
        assert_eq!(p.line(), Some(2), "clear keeps the match line");
        assert!(!p.find_active());
    }

    #[test]
    fn find_requires_text_content() {
        let mut p = Preview::new();
        p.set_dir("src", vec![]);
        assert!(!p.findable());
        p.begin_find();
        assert!(!p.find_active(), "dir summaries can't be searched");
    }

    #[test]
    fn new_content_drops_the_session() {
        let mut p = findable_preview();
        p.begin_find();
        p.update_find("ratatui".into());
        assert!(p.find_active());
        p.set_bytes("other.rs", b"fresh\n");
        assert!(!p.find_active());
        assert_eq!(p.line(), Some(1));
    }

    #[test]
    fn find_is_case_insensitive() {
        let mut p = Preview::new();
        p.set_bytes("a.rs", b"Ratatui RATATUI\n");
        p.begin_find();
        p.update_find("ratatui".into());
        assert_eq!(p.readout().as_deref(), Some("1/2 · 1/1"));
    }
}