gitu/

picker.rs

use fuzzy_matcher::FuzzyMatcher;
use fuzzy_matcher::skim::SkimMatcherV2;
use std::borrow::Cow;

use crate::item_data::Ref;
use crate::item_data::Rev;
use crate::text_input::TextInput;

/// Data that can be selected in a picker
#[derive(Debug, Clone, PartialEq)]
pub enum PickerData {
    /// A selected item value
    Item(String),
    /// Custom user input (literal text from input field)
    CustomInput(String),
}

impl PickerData {
    pub fn display(&self) -> &str {
        match self {
            PickerData::Item(s) | PickerData::CustomInput(s) => s,
        }
    }
}

/// What a picker whose items can be given keys ended with.
#[derive(Debug, Clone, PartialEq)]
pub(crate) enum Picked {
    Item(PickerData),
    /// The item was given this key, rather than picked.
    KeySet(char, PickerData),
}

/// An item in the picker list
#[derive(Debug, Clone, PartialEq)]
pub struct PickerItem {
    /// The text to display and match against
    pub display: Cow<'static, str>,
    /// Associated data
    pub data: PickerData,
    /// Whether moving through a picker shown as one row stops here. The list
    /// always does.
    pub in_one_row: bool,
}

impl PickerItem {
    pub fn new(display: impl Into<Cow<'static, str>>, data: PickerData) -> Self {
        Self {
            display: display.into(),
            data,
            in_one_row: true,
        }
    }

    /// An item that moving through a picker shown as one row passes over.
    pub(crate) fn only_in_list(mut self) -> Self {
        self.in_one_row = false;
        self
    }
}

/// Result of a fuzzy match with score
#[derive(Debug, Clone)]
struct MatchResult {
    index: usize,
    score: i64,
}

/// Picker status
#[derive(Debug, Clone, PartialEq)]
pub enum PickerStatus {
    /// Picker is active
    Active,
    /// User selected an item
    Done,
    /// User cancelled
    Cancelled,
    /// User gave the selected item this key
    KeySet(char),
}

/// State of the picker component
pub struct PickerState {
    /// All available items (excluding custom input)
    items: Vec<PickerItem>,
    /// Filtered and sorted indices based on current pattern
    filtered_indices: Vec<usize>,
    /// Current cursor position in filtered results
    cursor: usize,
    /// Current input pattern
    pub(crate) input_state: TextInput,
    /// Fuzzy matcher
    matcher: SkimMatcherV2,
    /// Prompt text to display
    pub prompt_text: Cow<'static, str>,
    /// Current status
    status: PickerStatus,
    /// Allow user to input custom value not in the list
    allow_custom_input: bool,
    /// Custom input item (separate from items list)
    custom_input_item: Option<PickerItem>,
    /// Whether a letter gives the selected item a key, rather than filtering.
    assigns_keys: bool,
    /// For a picker that can be shown as one row, whether it is: the selected
    /// item alone, with letters not typed. `None` for a picker that is always a
    /// list.
    one_row: Option<bool>,
    /// For a picker shown in columns, the columns.
    grid: Option<Grid>,
}

/// A picker's items laid out in columns side by side, each under a heading.
pub(crate) struct Grid {
    pub(crate) headings: Vec<&'static str>,
    /// The column of each item, by its index among the items.
    columns: Vec<usize>,
}

impl Grid {
    pub(crate) fn column_of(&self, item_i: usize) -> usize {
        self.columns[item_i]
    }
}

pub(crate) struct PickerParams<'a> {
    pub(crate) prompt: Cow<'static, str>,
    pub(crate) refs: &'a [Ref],
    pub(crate) exclude_ref: Option<Ref>,
    pub(crate) default: Option<Rev>,
    pub(crate) allow_custom_input: bool,
}

impl PickerState {
    /// Create a new picker with items
    pub fn new(
        prompt: impl Into<Cow<'static, str>>,
        items: Vec<PickerItem>,
        allow_custom_input: bool,
    ) -> Self {
        let mut state = Self {
            items: items.clone(),
            filtered_indices: Vec::new(),
            cursor: 0,
            input_state: TextInput::default(),
            matcher: SkimMatcherV2::default(),
            prompt_text: prompt.into(),
            status: PickerStatus::Active,
            allow_custom_input,
            custom_input_item: None,
            assigns_keys: false,
            one_row: None,
            grid: None,
        };
        state.update_filter();
        state
    }

    /// Make a letter give the selected item a key, rather than filter: the list
    /// is moved through, not searched.
    pub(crate) fn assigning_keys(mut self) -> Self {
        self.assigns_keys = true;
        self
    }

    /// Show the picker as one row, the selected item alone, until it is
    /// switched to a list by [`Self::toggle_one_row`].
    pub(crate) fn one_row(mut self) -> Self {
        self.one_row = Some(true);
        self
    }

    /// Show the items in columns side by side, each under its heading in
    /// `headings`: the column of each item is its entry in `columns`. Up and
    /// down then move within a column, and left and right between columns.
    pub(crate) fn in_columns(mut self, headings: Vec<&'static str>, columns: Vec<usize>) -> Self {
        self.grid = Some(Grid { headings, columns });
        self
    }

    pub(crate) fn grid(&self) -> Option<&Grid> {
        self.grid.as_ref()
    }

    /// The positions in the filtered list of the items in column `column`.
    pub(crate) fn column_positions(&self, column: usize) -> Vec<usize> {
        let Some(grid) = &self.grid else {
            return vec![];
        };
        (0..self.filtered_indices.len())
            .filter(|&position| grid.column_of(self.filtered_indices[position]) == column)
            .collect()
    }

    /// The column of the selected item, in a grid.
    pub(crate) fn cursor_column(&self) -> Option<usize> {
        let grid = self.grid.as_ref()?;
        let item_i = *self.filtered_indices.get(self.cursor)?;
        Some(grid.column_of(item_i))
    }

    /// In a grid, move to the column `step` columns along that has items, to
    /// the row the cursor is on, or the last row of a shorter column. Past the
    /// first or last such column, the cursor stays where it is.
    pub(crate) fn move_column(&mut self, step: isize) {
        let (Some(grid), Some(column)) = (&self.grid, self.cursor_column()) else {
            return;
        };
        let row = self
            .column_positions(column)
            .iter()
            .position(|&position| position == self.cursor)
            .unwrap_or(0);
        let mut target = column;
        loop {
            let Some(next) = target
                .checked_add_signed(step)
                .filter(|&next| next < grid.headings.len())
            else {
                return;
            };
            target = next;
            let positions = self.column_positions(target);
            if let Some(&position) = positions.get(row).or(positions.last()) {
                self.cursor = position;
                return;
            }
        }
    }

    pub(crate) fn is_one_row(&self) -> bool {
        self.one_row == Some(true)
    }

    /// Switch a picker made with [`Self::one_row`] between one row and a list.
    /// The search typed in the list stays, so one row moves through what it
    /// matched.
    pub(crate) fn toggle_one_row(&mut self) {
        if let Some(one_row) = &mut self.one_row {
            *one_row = !*one_row;
        }
    }

    pub(crate) fn with_cursor(mut self, cursor: usize) -> Self {
        if cursor < self.filtered_indices.len() {
            self.cursor = cursor;
        }
        self
    }

    pub(crate) fn assigns_keys(&self) -> bool {
        self.assigns_keys
    }

    pub(crate) fn set_key(&mut self, key: char) {
        self.status = PickerStatus::KeySet(key);
    }

    /// Create a picker showing only local branches by shorthand name.
    /// The default branch (if any) is listed first. The exclude_ref is omitted.
    pub(crate) fn with_branches(params: PickerParams) -> Self {
        let default_name = params.default.as_ref().map(|r| r.shorthand().to_string());
        let exclude_name = params
            .exclude_ref
            .as_ref()
            .map(|r| r.shorthand().to_string());

        let items = default_name
            .iter()
            .map(|name| PickerItem::new(name.clone(), PickerData::Item(name.clone())))
            .chain(
                params
                    .refs
                    .iter()
                    .filter(|r| matches!(r, Ref::Head(_)))
                    .filter(|r| exclude_name.as_deref().is_none_or(|e| e != r.shorthand()))
                    .filter(|r| default_name.as_deref().is_none_or(|d| d != r.shorthand()))
                    .map(|r| {
                        let name = r.shorthand().to_string();
                        PickerItem::new(name.clone(), PickerData::Item(name))
                    }),
            )
            .collect();

        Self::new(params.prompt, items, params.allow_custom_input)
    }

    /// Create a picker from refs. Tags are prefixed with "tag: " in display.
    /// The default ref (if any) is listed first. The exclude_ref is omitted.
    pub(crate) fn with_refs(params: PickerParams) -> Self {
        let ref_to_item = |r: &Ref| {
            let (display, refname) = match r {
                Ref::Tag(name) => (format!("tag: {}", name), r.to_full_refname()),
                _ => (r.shorthand().to_string(), r.shorthand().to_string()),
            };
            PickerItem::new(display, PickerData::Item(refname))
        };

        let default_item = params.default.as_ref().map(|default| match default {
            Rev::Ref(r) => ref_to_item(r),
            Rev::Commit(c) => PickerItem::new(c.clone(), PickerData::Item(c.clone())),
        });

        let items = default_item
            .into_iter()
            .chain(
                params
                    .refs
                    .iter()
                    .filter(|r| {
                        params.exclude_ref.as_ref().is_none_or(|e| e != *r)
                            && params.default.as_ref().is_none_or(|d| match d {
                                Rev::Ref(d) => d != *r,
                                _ => true,
                            })
                    })
                    .map(ref_to_item),
            )
            .collect();

        Self::new(params.prompt, items, params.allow_custom_input)
    }

    /// Get current input pattern
    pub fn pattern(&self) -> &str {
        &self.input_state.value
    }

    /// Update the filter based on current input pattern
    pub fn update_filter(&mut self) {
        let pattern = self.pattern().to_string();

        if pattern.is_empty() {
            // Show all items when no pattern
            self.filtered_indices = (0..self.items.len()).collect();
            self.custom_input_item = None;
        } else {
            // Fuzzy match and sort by score
            let mut matches: Vec<MatchResult> = self
                .items
                .iter()
                .enumerate()
                .filter_map(|(i, item)| {
                    self.matcher
                        .fuzzy_match(&item.display, &pattern)
                        .map(|score| MatchResult { index: i, score })
                })
                .collect();

            // Sort by score (higher is better)
            matches.sort_by_key(|b| std::cmp::Reverse(b.score));

            self.filtered_indices = matches.into_iter().map(|m| m.index).collect();

            // Create custom input item if enabled
            if self.allow_custom_input {
                self.custom_input_item = Some(PickerItem::new(
                    pattern.clone(),
                    PickerData::CustomInput(pattern),
                ));
            } else {
                self.custom_input_item = None;
            }
        }

        // Reset cursor if out of bounds
        let total_count = self.filtered_indices.len()
            + if self.custom_input_item.is_some() {
                1
            } else {
                0
            };
        if self.cursor >= total_count {
            self.cursor = 0;
        }
    }

    /// Get the currently selected item, if any
    pub fn selected(&self) -> Option<&PickerItem> {
        // Check if cursor is on custom input item (always at the end)
        if self.cursor == self.filtered_indices.len() {
            return self.custom_input_item.as_ref();
        }

        self.filtered_indices
            .get(self.cursor)
            .and_then(|&i| self.items.get(i))
    }

    /// Get all filtered items with their original indices
    /// Custom input item (if present) is always last with index usize::MAX
    pub fn filtered_items(&self) -> impl Iterator<Item = (usize, &PickerItem)> {
        self.filtered_indices
            .iter()
            .filter_map(|&i| self.items.get(i).map(|item| (i, item)))
            .chain(
                self.custom_input_item
                    .as_ref()
                    .map(|item| (usize::MAX, item)),
            )
    }

    /// Move cursor to next item, in a grid the next in its column.
    pub fn next(&mut self) {
        if !self.step_in_column(1) {
            self.step(|cursor, total| (cursor + 1) % total);
        }
    }

    /// Move cursor to previous item, in a grid the previous in its column.
    pub fn previous(&mut self) {
        if !self.step_in_column(-1) {
            self.step(|cursor, total| (cursor + total - 1) % total);
        }
    }

    /// In a grid, move `step` items along the cursor's column, wrapping round
    /// its ends, and say so; otherwise do nothing.
    fn step_in_column(&mut self, step: isize) -> bool {
        let Some(column) = self.cursor_column() else {
            return false;
        };
        let positions = self.column_positions(column);
        let row = positions
            .iter()
            .position(|&position| position == self.cursor)
            .unwrap_or(0);
        let len = positions.len() as isize;
        self.cursor = positions[(row as isize + step).rem_euclid(len) as usize];
        true
    }

    /// Move the cursor by `step` until it is on an item it stops on: any item in
    /// the list, and in one row only those [`PickerItem::in_one_row`]. If there
    /// is none, it stays where it is.
    fn step(&mut self, step: impl Fn(usize, usize) -> usize) {
        let total = self.filtered_indices.len() + usize::from(self.custom_input_item.is_some());
        let mut cursor = self.cursor;
        for _ in 0..total {
            cursor = step(cursor, total);
            let stops = !self.is_one_row()
                || self
                    .filtered_indices
                    .get(cursor)
                    .is_none_or(|&i| self.items[i].in_one_row);
            if stops {
                self.cursor = cursor;
                return;
            }
        }
    }

    /// In one row, the items it stops on, numbered from 0, as (number, position
    /// in the filtered list).
    fn one_row_stops(&self) -> impl Iterator<Item = (usize, usize)> + '_ {
        self.filtered_indices
            .iter()
            .enumerate()
            .filter(|(_, i)| self.items[**i].in_one_row)
            .map(|(position, _)| position)
            .enumerate()
    }

    /// The number of the selected item among those one row stops on, and the
    /// highest number: what a digit selects. `None` for an item it passes over.
    pub(crate) fn one_row_number(&self) -> (Option<usize>, usize) {
        let mut number = None;
        let mut last = 0;
        for (n, position) in self.one_row_stops() {
            if position == self.cursor {
                number = Some(n);
            }
            last = n;
        }
        (number, last)
    }

    /// Move the cursor to the item one row numbers `number`, if there is one.
    pub(crate) fn select_number(&mut self, number: usize) {
        let position = self.one_row_stops().find(|(n, _)| *n == number);
        if let Some((_, position)) = position {
            self.cursor = position;
        }
    }

    /// Get current cursor position
    pub fn cursor(&self) -> usize {
        self.cursor
    }

    /// Get total number of items
    pub fn total_items(&self) -> usize {
        self.items.len()
    }

    /// Get number of filtered items
    pub fn filtered_count(&self) -> usize {
        self.filtered_indices.len()
    }

    /// Get the fuzzy match positions for a given item (for highlighting)
    pub fn match_indices(&self, item_index: usize) -> Option<Vec<usize>> {
        let pattern = self.pattern();
        if pattern.is_empty() {
            return None;
        }

        // Don't highlight custom input items (marked with usize::MAX)
        if item_index == usize::MAX {
            return None;
        }

        self.items
            .get(item_index)
            .and_then(|item| self.matcher.fuzzy_indices(&item.display, pattern))
            .map(|(_, indices)| indices)
    }

    /// Get current status
    pub fn status(&self) -> &PickerStatus {
        &self.status
    }

    /// Mark picker as done (user selected an item)
    pub fn done(&mut self) {
        self.status = PickerStatus::Done;
    }

    /// Mark picker as cancelled (user cancelled)
    pub fn cancel(&mut self) {
        self.status = PickerStatus::Cancelled;
    }

    /// Check if picker is done
    pub fn is_done(&self) -> bool {
        self.status == PickerStatus::Done
    }

    /// Check if picker is cancelled
    pub fn is_cancelled(&self) -> bool {
        self.status == PickerStatus::Cancelled
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};

    fn create_test_items() -> Vec<PickerItem> {
        vec![
            PickerItem::new("main", PickerData::Item("main".to_string())),
            PickerItem::new("develop", PickerData::Item("develop".to_string())),
            PickerItem::new("feature/test", PickerData::Item("feature/test".to_string())),
            PickerItem::new("feature/new", PickerData::Item("feature/new".to_string())),
            PickerItem::new("bugfix/123", PickerData::Item("bugfix/123".to_string())),
        ]
    }

    #[test]
    fn test_picker_data_display() {
        let revision = PickerData::Item("main".to_string());
        assert_eq!(revision.display(), "main");

        let custom = PickerData::CustomInput("custom".to_string());
        assert_eq!(custom.display(), "custom");
    }

    #[test]
    fn test_picker_item_new() {
        let item = PickerItem::new("main", PickerData::Item("main".to_string()));
        assert_eq!(item.display.as_ref(), "main");
        assert_eq!(item.data.display(), "main");
    }

    #[test]
    fn test_picker_state_new_without_custom_input() {
        let items = create_test_items();
        let state = PickerState::new("Select branch", items.clone(), false);

        assert_eq!(state.prompt_text.as_ref(), "Select branch");
        assert_eq!(state.total_items(), 5);
        assert_eq!(state.filtered_count(), 5);
        assert_eq!(state.cursor(), 0);
        assert_eq!(state.pattern(), "");
        assert_eq!(state.status(), &PickerStatus::Active);
        assert!(!state.allow_custom_input);
    }

    #[test]
    fn test_picker_state_new_with_custom_input() {
        let items = create_test_items();
        let state = PickerState::new("Select branch", items, true);

        assert!(state.allow_custom_input);
        assert_eq!(state.custom_input_item, None); // No custom item when pattern is empty
    }

    #[test]
    fn test_empty_pattern_shows_all_items() {
        let items = create_test_items();
        let state = PickerState::new("Select", items, false);

        assert_eq!(state.filtered_count(), 5);
        assert_eq!(state.filtered_indices, vec![0, 1, 2, 3, 4]);
    }

    #[test]
    fn test_fuzzy_filtering() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::empty()));
        state.update_filter();

        // Should match "feature/test", "feature/new", and "bugfix/123" (fuzzy match)
        assert_eq!(state.filtered_count(), 3);

        let filtered: Vec<_> = state.filtered_items().collect();
        assert!(
            filtered
                .iter()
                .any(|(_, item)| item.display == "feature/test")
        );
        assert!(
            filtered
                .iter()
                .any(|(_, item)| item.display == "feature/new")
        );
        assert!(
            filtered
                .iter()
                .any(|(_, item)| item.display == "bugfix/123")
        );
    }

    #[test]
    fn test_fuzzy_filtering_sorts_by_score() {
        // Create items with varying match quality for pattern "feat"
        let items = vec![
            PickerItem::new("feat", PickerData::Item("feat".to_string())), // Exact match
            PickerItem::new("feature", PickerData::Item("feature".to_string())), // Prefix match
            PickerItem::new("feature/test", PickerData::Item("feature/test".to_string())), // Prefix with more chars
            PickerItem::new("fix-eat-bug", PickerData::Item("fix-eat-bug".to_string())), // Scattered match
        ];
        let mut state = PickerState::new("Select", items, false);

        // Type "feat" pattern
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::empty()));
        state.update_filter();

        // All should match
        assert_eq!(state.filtered_count(), 4);

        // Verify sorted by score: exact match > prefix match > scattered match
        let filtered: Vec<_> = state
            .filtered_items()
            .map(|(_, item)| item.display.as_ref())
            .collect();

        // "feat" (exact) should be first, "fix-eat-bug" (scattered) should be last
        assert_eq!(filtered[0], "feat");
        assert_eq!(filtered[filtered.len() - 1], "fix-eat-bug");
    }

    #[test]
    fn test_case_insensitive_matching() {
        let items = vec![
            PickerItem::new("Feature", PickerData::Item("Feature".to_string())),
            PickerItem::new("feature", PickerData::Item("feature".to_string())),
            PickerItem::new("FEATURE", PickerData::Item("FEATURE".to_string())),
        ];

        let mut state = PickerState::new("Select item", items, false);

        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::empty()));
        state.update_filter();

        // fuzzy-matcher is case-insensitive by default
        assert_eq!(state.filtered_count(), 3);
    }

    #[test]
    fn test_no_matches() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('z'), KeyModifiers::empty()));
        state.update_filter();

        assert_eq!(state.filtered_count(), 0);
        assert!(state.selected().is_none());
    }

    #[test]
    fn test_custom_input_creation() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, true);

        // Use pattern "fea" which matches feature/test and feature/new
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::empty()));
        state.update_filter();

        // Custom input item should be created
        assert!(state.custom_input_item.is_some());

        // Should have multiple regular matches + custom input
        let filtered: Vec<_> = state.filtered_items().collect();
        assert!(filtered.len() >= 3); // At least 2 feature items + bugfix + custom input

        // Custom input should be last in filtered items
        let last = filtered.last().unwrap();
        assert_eq!(last.0, usize::MAX);
        assert_eq!(last.1.display.as_ref(), "fea");
    }

    #[test]
    fn test_custom_input_not_created_when_disabled() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::empty()));
        state.update_filter();

        assert!(state.custom_input_item.is_none());
    }

    #[test]
    fn test_custom_input_not_created_on_empty_pattern() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, true);

        // Start with no input
        assert!(state.custom_input_item.is_none());

        // Add then remove input
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::empty()));
        state.update_filter();
        assert!(state.custom_input_item.is_some());

        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::empty()));
        state.update_filter();
        assert!(state.custom_input_item.is_none());
    }

    #[test]
    fn test_cursor_next() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        assert_eq!(state.cursor(), 0);

        state.next();
        assert_eq!(state.cursor(), 1);

        state.next();
        assert_eq!(state.cursor(), 2);
    }

    #[test]
    fn test_cursor_next_wraps_around() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        // Move to end
        for _ in 0..5 {
            state.next();
        }

        // Should wrap to 0
        assert_eq!(state.cursor(), 0);
    }

    #[test]
    fn test_cursor_previous() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        state.next();
        state.next();
        assert_eq!(state.cursor(), 2);

        state.previous();
        assert_eq!(state.cursor(), 1);

        state.previous();
        assert_eq!(state.cursor(), 0);
    }

    #[test]
    fn test_cursor_previous_wraps_around() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        assert_eq!(state.cursor(), 0);

        state.previous();
        // Should wrap to last item
        assert_eq!(state.cursor(), 4);
    }

    #[test]
    fn test_cursor_with_custom_input() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, true);

        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::empty()));
        state.update_filter();

        // 3 matched items (feature/test, feature/new, bugfix/123) + 1 custom input = 4 total
        assert_eq!(state.cursor(), 0);

        state.next();
        assert_eq!(state.cursor(), 1);

        state.next();
        assert_eq!(state.cursor(), 2);

        state.next();
        assert_eq!(state.cursor(), 3); // Custom input position

        state.next();
        assert_eq!(state.cursor(), 0); // Wrapped around forward

        state.previous();
        assert_eq!(state.cursor(), 3); // Wrapped around backward to custom input
    }

    #[test]
    fn test_navigation_with_custom_input_at_end() {
        let items = vec![
            PickerItem::new("feature/a", PickerData::Item("feature/a".to_string())),
            PickerItem::new("feature/b", PickerData::Item("feature/b".to_string())),
        ];

        let mut state = PickerState::new("Select", items, true);

        // Type "feat" to get matches + custom input
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::empty()));
        state.update_filter();

        // Should have 2 matches + custom input = 3 total
        assert_eq!(state.filtered_count(), 2);
        assert_eq!(state.cursor(), 0);

        // Navigate to first match
        let selected = state.selected().unwrap();
        match &selected.data {
            PickerData::Item(_) => {}
            _ => panic!("Expected first item to be a revision"),
        }

        // Navigate to second match
        state.next();
        assert_eq!(state.cursor(), 1);

        // Navigate to custom input (last item)
        state.next();
        assert_eq!(state.cursor(), 2);
        let selected = state.selected().unwrap();
        match &selected.data {
            PickerData::CustomInput(s) => assert_eq!(s, "feat"),
            _ => panic!("Expected custom input at end"),
        }

        // Wrap around to first
        state.next();
        assert_eq!(state.cursor(), 0);
    }

    #[test]
    fn test_cursor_resets_when_filter_reduces_items() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        // Move cursor to position 4
        for _ in 0..4 {
            state.next();
        }
        assert_eq!(state.cursor(), 4);

        // Filter to only 2 items
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::empty()));
        state.update_filter();

        // Cursor should reset to 0
        assert_eq!(state.cursor(), 0);
    }

    #[test]
    fn test_scroll_through_many_items() {
        // Create 20 items to test scrolling behavior
        let items: Vec<_> = (0..20)
            .map(|i| {
                PickerItem::new(
                    format!("branch-{:02}", i),
                    PickerData::Item(format!("branch-{:02}", i)),
                )
            })
            .collect();

        let mut state = PickerState::new("Select", items, false);

        // Start at first item
        assert_eq!(state.cursor(), 0);

        // Navigate to middle item
        for _ in 0..10 {
            state.next();
        }
        assert_eq!(state.cursor(), 10);

        // Navigate to last item
        for _ in 0..9 {
            state.next();
        }
        assert_eq!(state.cursor(), 19);

        // Wrap around to first
        state.next();
        assert_eq!(state.cursor(), 0);

        // Navigate backwards
        state.previous();
        assert_eq!(state.cursor(), 19);
    }

    #[test]
    fn test_navigation_after_filtering() {
        let items = vec![
            PickerItem::new("feature/a", PickerData::Item("feature/a".to_string())),
            PickerItem::new("feature/b", PickerData::Item("feature/b".to_string())),
            PickerItem::new("main", PickerData::Item("main".to_string())),
            PickerItem::new("develop", PickerData::Item("develop".to_string())),
        ];

        let mut state = PickerState::new("Select", items, false);

        // Filter to get only feature/* branches
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::empty()));
        state.update_filter();

        // Should have 2 filtered items
        assert_eq!(state.filtered_count(), 2);
        assert_eq!(state.cursor(), 0);

        // Navigate through filtered items
        state.next();
        assert_eq!(state.cursor(), 1);

        // Wrap around
        state.next();
        assert_eq!(state.cursor(), 0);

        // Go backwards
        state.previous();
        assert_eq!(state.cursor(), 1);
    }

    #[test]
    fn test_selected_returns_correct_item() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        let selected = state.selected().unwrap();
        assert_eq!(selected.display.as_ref(), "main");

        state.next();
        state.next();
        let selected = state.selected().unwrap();
        assert_eq!(selected.display.as_ref(), "feature/test");
    }

    #[test]
    fn test_selected_with_filter() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('b'), KeyModifiers::empty()));
        state.update_filter();

        // Should match "bugfix/123"
        let selected = state.selected().unwrap();
        assert_eq!(selected.display.as_ref(), "bugfix/123");
    }

    #[test]
    fn test_selected_returns_custom_input() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, true);

        // Use a pattern that doesn't match any items
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::empty()));
        state.update_filter();

        // No matches, only custom input at cursor 0
        assert_eq!(state.cursor(), 0);
        assert_eq!(state.selected().unwrap().display.as_ref(), "qq");
    }

    #[test]
    fn test_select_custom_input() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, true);

        // Type a pattern that doesn't match anything
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('z'), KeyModifiers::empty()));
        state.update_filter();

        // Should have no matches but custom input
        assert_eq!(state.filtered_count(), 0);
        assert!(state.custom_input_item.is_some());

        // Cursor should be at custom input (position 0 since no other items)
        assert_eq!(state.cursor(), 0);

        // Selected item should be the custom input
        let selected = state.selected().unwrap();
        assert_eq!(selected.display, "xyz");
        match &selected.data {
            PickerData::CustomInput(s) => assert_eq!(s, "xyz"),
            _ => panic!("Expected CustomInput"),
        }

        // Mark as done
        state.done();
        assert!(state.is_done());
        assert_eq!(state.status(), &PickerStatus::Done);
    }

    #[test]
    fn test_filtered_items_order() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, true);

        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::empty()));
        state.update_filter();

        let indices: Vec<_> = state.filtered_items().map(|(idx, _)| idx).collect();

        // Verify normal item indices followed by custom input
        assert_eq!(indices[0], 2); // feature/test
        assert_eq!(indices[1], 3); // feature/new
        assert_eq!(indices[2], 4); // bugfix/123
        assert_eq!(indices[3], usize::MAX); // custom input
    }

    #[test]
    fn test_match_indices_with_pattern() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::empty()));
        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::empty()));
        state.update_filter();

        // Get the index of "main" in original items
        let indices = state.match_indices(0);
        assert!(indices.is_some());

        let indices = indices.unwrap();
        assert_eq!(indices.len(), 3); // 'm', 'a', 'i' should match
    }

    #[test]
    fn test_match_indices_empty_pattern() {
        let items = create_test_items();
        let state = PickerState::new("Select", items, false);

        let indices = state.match_indices(0);
        assert!(indices.is_none());
    }

    #[test]
    fn test_match_indices_custom_input_returns_none() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, true);

        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::empty()));
        state.update_filter();

        // usize::MAX is used for custom input items
        let indices = state.match_indices(usize::MAX);
        assert!(indices.is_none());
    }

    #[test]
    fn test_status_transitions() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        assert_eq!(state.status(), &PickerStatus::Active);
        assert!(!state.is_done());
        assert!(!state.is_cancelled());

        state.done();
        assert_eq!(state.status(), &PickerStatus::Done);
        assert!(state.is_done());
        assert!(!state.is_cancelled());
    }

    #[test]
    fn test_status_cancelled() {
        let items = create_test_items();
        let mut state = PickerState::new("Select", items, false);

        state.cancel();
        assert_eq!(state.status(), &PickerStatus::Cancelled);
        assert!(!state.is_done());
        assert!(state.is_cancelled());
    }

    #[test]
    fn test_empty_items_list() {
        let state = PickerState::new("Select", vec![], false);

        assert_eq!(state.total_items(), 0);
        assert_eq!(state.filtered_count(), 0);
        assert_eq!(state.cursor(), 0);
        assert!(state.selected().is_none());
    }

    #[test]
    fn test_empty_items_with_custom_input() {
        let mut state = PickerState::new("Select", vec![], true);

        state
            .input_state
            .handle_key_event(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::empty()));
        state.update_filter();

        assert_eq!(state.total_items(), 0);
        assert_eq!(state.filtered_count(), 0);
        assert!(state.custom_input_item.is_some());

        assert_eq!(state.selected().unwrap().display.as_ref(), "a");
    }

    #[test]
    fn test_cursor_navigation_empty_list() {
        let mut state = PickerState::new("Select", vec![], false);

        state.next();
        assert_eq!(state.cursor(), 0);

        state.previous();
        assert_eq!(state.cursor(), 0);
    }

    #[test]
    fn test_single_item_navigation() {
        let items = vec![PickerItem::new(
            "only",
            PickerData::Item("only".to_string()),
        )];
        let mut state = PickerState::new("Select", items, false);

        assert_eq!(state.cursor(), 0);

        state.next();
        assert_eq!(state.cursor(), 0); // Wraps to same item

        state.previous();
        assert_eq!(state.cursor(), 0); // Wraps to same item
    }

    #[test]
    fn test_with_refs_basic_sorting() {
        // Test that items are sorted as: default -> branches -> tags -> remotes
        let refs = &[
            Ref::Tag("v1.0.0".to_string()),
            Ref::Remote("origin/main".to_string()),
            Ref::Head("feature".to_string()),
            Ref::Head("main".to_string()),
            Ref::Tag("v2.0.0".to_string()),
        ];

        let state = PickerState::with_refs(PickerParams {
            prompt: "Select".into(),
            refs,
            exclude_ref: None,
            default: None,
            allow_custom_input: false,
        });

        let items: Vec<_> = state
            .filtered_items()
            .map(|(_, item)| item.display.as_ref())
            .collect();

        // Order is preserved from input
        assert_eq!(
            items,
            &[
                "tag: v1.0.0",
                "origin/main",
                "feature",
                "main",
                "tag: v2.0.0"
            ]
        )
    }

    #[test]
    fn test_with_refs_empty_list() {
        let state = PickerState::with_refs(PickerParams {
            prompt: "Select".into(),
            refs: &[],
            exclude_ref: None,
            default: None,
            allow_custom_input: false,
        });

        assert_eq!(state.total_items(), 0);
        assert_eq!(state.filtered_count(), 0);
        assert!(state.selected().is_none());
    }

    #[test]
    fn test_with_refs_with_default() {
        // Test that default ref is shown first
        let refs = &[
            Ref::Head("feature".to_string()),
            Ref::Head("main".to_string()),
            Ref::Tag("v1.0.0".to_string()),
        ];

        let default = Some(Rev::Ref(Ref::Head("main".to_string())));
        let state = PickerState::with_refs(PickerParams {
            prompt: "Select".into(),
            refs,
            exclude_ref: None,
            default,
            allow_custom_input: false,
        });

        let items: Vec<_> = state
            .filtered_items()
            .map(|(_, item)| item.display.as_ref())
            .collect();

        // Default should be first, then remaining in input order
        assert_eq!(&items, &["main", "feature", "tag: v1.0.0"]);
    }

    #[test]
    fn test_with_refs_exclude_ref() {
        // Test that excluded ref is not shown
        let refs = &[
            Ref::Head("feature".to_string()),
            Ref::Head("main".to_string()),
            Ref::Tag("v1.0.0".to_string()),
        ];

        let state = PickerState::with_refs(PickerParams {
            prompt: "Select".into(),
            refs,
            exclude_ref: Some(Ref::Head("main".to_string())),
            default: None,
            allow_custom_input: false,
        });

        let items: Vec<_> = state
            .filtered_items()
            .map(|(_, item)| item.display.as_ref())
            .collect();

        // main should be excluded
        assert_eq!(&items, &["feature", "tag: v1.0.0"])
    }

    #[test]
    fn test_with_refs_duplicate_names() {
        // Tag and branch with same name are disambiguated by "tag: " prefix
        let refs = &[
            Ref::Head("v1.0.0".to_string()),
            Ref::Tag("v1.0.0".to_string()),
            Ref::Head("main".to_string()),
        ];

        let state = PickerState::with_refs(PickerParams {
            prompt: "Select".into(),
            refs,
            exclude_ref: None,
            default: None,
            allow_custom_input: false,
        });

        let items: Vec<_> = state
            .filtered_items()
            .map(|(_, item)| item.display.as_ref())
            .collect();

        assert_eq!(&items, &["v1.0.0", "tag: v1.0.0", "main"])
    }

    #[test]
    fn test_with_refs_duplicate_with_default() {
        // Tag default shown with "tag: " prefix
        let refs = &[
            Ref::Head("v1.0.0".to_string()),
            Ref::Tag("v1.0.0".to_string()),
            Ref::Head("main".to_string()),
        ];

        let state = PickerState::with_refs(PickerParams {
            prompt: "Select".into(),
            refs,
            exclude_ref: None,
            default: Some(Rev::Ref(Ref::Tag("v1.0.0".to_string()))),
            allow_custom_input: false,
        });

        let items: Vec<_> = state
            .filtered_items()
            .map(|(_, item)| item.display.as_ref())
            .collect();

        assert_eq!(items, &["tag: v1.0.0", "v1.0.0", "main"])
    }

    #[test]
    fn test_with_refs_exclude_and_default_same() {
        // Test when exclude and default are the same
        // The implementation adds default first, then filters exclude from remaining items
        // So if default == exclude, default is still added, then exclude filters it from the rest
        let refs = &[
            Ref::Head("feature".to_string()),
            Ref::Head("main".to_string()),
        ];

        let state = PickerState::with_refs(PickerParams {
            prompt: "Select".into(),
            refs,
            exclude_ref: Some(Ref::Head("main".to_string())),
            default: Some(Rev::Ref(Ref::Head("main".to_string()))),
            allow_custom_input: false,
        });

        let items: Vec<_> = state
            .filtered_items()
            .map(|(_, item)| item.display.as_ref())
            .collect();

        // Default is added first, then exclude filters remaining items
        // So we get: main (default) + feature (not excluded)
        assert_eq!(&items, &["main", "feature"])
    }

    #[test]
    fn test_with_refs_with_custom_input() {
        let refs = &[
            Ref::Head("main".to_string()),
            Ref::Tag("v1.0.0".to_string()),
        ];

        let state = PickerState::with_refs(PickerParams {
            prompt: "Select".into(),
            refs,
            exclude_ref: None,
            default: None,
            allow_custom_input: true,
        });

        // Custom input should be allowed
        assert!(state.allow_custom_input);

        // With empty pattern, no custom input item
        assert!(state.custom_input_item.is_none());
    }

    #[test]
    fn test_with_refs_exclude_tag_sibling() {
        // If branch is excluded, remaining tag still shows "tag: " prefix
        let refs = &[
            Ref::Head("v1.0.0".to_string()),
            Ref::Tag("v1.0.0".to_string()),
        ];

        let state = PickerState::with_refs(PickerParams {
            prompt: "Select".into(),
            refs,
            exclude_ref: Some(Ref::Head("v1.0.0".to_string())),
            default: None,
            allow_custom_input: false,
        });

        let items: Vec<_> = state
            .filtered_items()
            .map(|(_, item)| item.display.as_ref())
            .collect();

        assert_eq!(&items, &["tag: v1.0.0"]);
    }

    #[test]
    fn test_with_refs_remote_tracking_default() {
        let refs = &[
            Ref::Head("main".to_string()),
            Ref::Remote("origin/main".to_string()),
            Ref::Remote("origin/feature".to_string()),
        ];

        let state = PickerState::with_refs(PickerParams {
            prompt: "Select".into(),
            refs,
            exclude_ref: None,
            default: Some(Rev::Ref(Ref::Remote("origin/main".to_string()))),
            allow_custom_input: false,
        });

        let items: Vec<_> = state
            .filtered_items()
            .map(|(_, item)| item.display.as_ref())
            .collect();

        // Default remote-tracking branch shown first as shorthand, then remaining
        assert_eq!(&items, &["origin/main", "main", "origin/feature"]);
    }
}