tui/widgets/

select.rs

//! Dropdown / list select widget.
//!
//! Holds an ordered list of options and a focused index. Navigation wraps
//! around within the type-ahead filtered set. The widget submits the focused
//! option's `id` (usually a UUID), not its display label.

/// A single entry in a [`SelectWidget`] option list.
#[derive(Debug, Clone)]
pub struct SelectOption {
    pub id: String,
    pub label: String,
}

/// A scrollable pick-list widget with type-ahead filtering.
///
/// `focused` indexes the **filtered** set returned by [`Self::matches`], not
/// `options` directly. When the filter matches nothing, `value()`/`display()`
/// return `""` and `next()`/`prev()` are no-ops.
#[derive(Debug, Clone)]
pub struct SelectWidget {
    options: Vec<SelectOption>,
    focused: usize,
    pub open: bool,
    query: String,
}

impl SelectWidget {
    #[must_use]
    pub fn new() -> Self {
        Self {
            options: Vec::new(),
            focused: 0,
            open: false,
            query: String::new(),
        }
    }

    /// Replace the option list, reset focus to 0, and clear any query.
    pub fn set_options(&mut self, options: Vec<SelectOption>) {
        self.options = options;
        self.focused = 0;
        self.query.clear();
    }

    /// Indices into `options` whose label contains `query` case-insensitively.
    /// An empty query returns all indices.
    #[must_use]
    pub fn matches(&self) -> Vec<usize> {
        if self.query.is_empty() {
            return (0..self.options.len()).collect();
        }
        let q = self.query.to_lowercase();
        self.options
            .iter()
            .enumerate()
            .filter(|(_, o)| o.label.to_lowercase().contains(&q))
            .map(|(i, _)| i)
            .collect()
    }

    /// The `id` of the focused filtered option, or `""` when no match exists.
    #[must_use]
    pub fn value(&self) -> &str {
        let m = self.matches();
        m.get(self.focused)
            .map(|&idx| self.options[idx].id.as_str())
            .unwrap_or("")
    }

    /// The display label of the focused filtered option, or `""` when no match.
    #[must_use]
    pub fn display(&self) -> &str {
        let m = self.matches();
        m.get(self.focused)
            .map(|&idx| self.options[idx].label.as_str())
            .unwrap_or("")
    }

    /// Number of options currently held (unfiltered).
    #[must_use]
    pub fn option_count(&self) -> usize {
        self.options.len()
    }

    /// The raw option list, for rendering.
    #[must_use]
    pub fn options(&self) -> &[SelectOption] {
        &self.options
    }

    /// The active type-ahead query string.
    #[must_use]
    pub fn query(&self) -> &str {
        &self.query
    }

    /// Index of the focused entry within the filtered set (i.e. `matches()`).
    #[must_use]
    pub fn focused_in_filtered(&self) -> usize {
        self.focused
    }

    /// Advance focus by one step within the filtered set, wrapping around.
    pub fn next(&mut self) {
        let n = self.matches().len();
        if n == 0 {
            return;
        }
        self.focused = (self.focused + 1) % n;
    }

    /// Retreat focus by one step within the filtered set, wrapping around.
    pub fn prev(&mut self) {
        let n = self.matches().len();
        if n == 0 {
            return;
        }
        self.focused = (self.focused + n - 1) % n;
    }

    /// Append a character to the type-ahead query and reset focus to 0.
    pub fn filter_push(&mut self, c: char) {
        self.query.push(c);
        self.focused = 0;
    }

    /// Remove the last character from the type-ahead query and reset focus to 0.
    pub fn filter_pop(&mut self) {
        self.query.pop();
        self.focused = 0;
    }

    /// Resolve the current filtered selection to the raw options index, clear
    /// the query, and close the dropdown. Call this on SelectConfirm so the
    /// selection survives query removal.
    pub fn confirm(&mut self) {
        let m = self.matches();
        let Some(&raw_idx) = m.get(self.focused) else {
            // Nothing matches the query — keep the filter open so the user can
            // correct it rather than silently committing the first option.
            return;
        };
        self.focused = raw_idx;
        self.query.clear();
        self.open = false;
    }

    /// Replace the option list, keeping the previously selected id focused if
    /// it exists in the new list; falls back to index 0 otherwise. Clears query.
    pub fn set_options_preserving_id(&mut self, options: Vec<SelectOption>) {
        let current_id = self.value().to_string();
        self.query.clear();
        self.options = options;
        self.focused = self
            .options
            .iter()
            .position(|o| o.id == current_id)
            .unwrap_or(0);
    }
}

impl Default for SelectWidget {
    fn default() -> Self {
        Self::new()
    }
}

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

    fn make_opts(n: usize) -> Vec<SelectOption> {
        (0..n)
            .map(|i| SelectOption {
                id: format!("id-{i}"),
                label: format!("Label {i}"),
            })
            .collect()
    }

    #[test]
    fn empty_widget_returns_empty_strings() {
        let w = SelectWidget::new();
        assert_eq!(w.value(), "");
        assert_eq!(w.display(), "");
    }

    #[test]
    fn zero_match_confirm_is_noop_and_keeps_query() {
        let mut w = SelectWidget::new();
        w.set_options(make_opts(3));
        for c in "zzz".chars() {
            w.filter_push(c);
        }
        assert!(w.matches().is_empty(), "query matches nothing");
        w.confirm();
        assert_eq!(
            w.value(),
            "",
            "confirm with no match must not silently select option 0"
        );
        assert_eq!(
            w.query(),
            "zzz",
            "query kept so the user can fix the filter"
        );
    }

    #[test]
    fn value_returns_focused_id() {
        let mut w = SelectWidget::new();
        w.set_options(make_opts(3));
        assert_eq!(w.value(), "id-0");
        w.next();
        assert_eq!(w.value(), "id-1");
    }

    #[test]
    fn display_returns_focused_label() {
        let mut w = SelectWidget::new();
        w.set_options(make_opts(3));
        assert_eq!(w.display(), "Label 0");
        w.next();
        assert_eq!(w.display(), "Label 1");
    }

    #[test]
    fn next_wraps_around() {
        let mut w = SelectWidget::new();
        w.set_options(make_opts(3));
        w.next();
        w.next(); // 0 → 1 → 2
        assert_eq!(w.value(), "id-2");
        w.next(); // wraps to 0
        assert_eq!(w.value(), "id-0");
    }

    #[test]
    fn prev_wraps_around() {
        let mut w = SelectWidget::new();
        w.set_options(make_opts(3));
        w.prev(); // 0 wraps to 2
        assert_eq!(w.value(), "id-2");
        w.prev(); // 2 → 1
        assert_eq!(w.value(), "id-1");
    }

    #[test]
    fn next_and_prev_noop_on_empty() {
        let mut w = SelectWidget::new();
        w.next();
        w.prev();
        assert_eq!(w.value(), "");
    }

    #[test]
    fn set_options_resets_focus() {
        let mut w = SelectWidget::new();
        w.set_options(make_opts(3));
        w.next();
        w.next();
        w.set_options(make_opts(2));
        assert_eq!(w.value(), "id-0");
    }

    #[test]
    fn set_options_preserving_id_keeps_selected_uuid() {
        let mut w = SelectWidget::new();
        w.set_options(vec![SelectOption {
            id: "uuid-42".to_string(),
            label: "uuid-42".to_string(),
        }]);
        assert_eq!(w.value(), "uuid-42");
        let full_list = vec![
            SelectOption {
                id: "uuid-10".to_string(),
                label: "First".to_string(),
            },
            SelectOption {
                id: "uuid-42".to_string(),
                label: "Second (proper label)".to_string(),
            },
            SelectOption {
                id: "uuid-99".to_string(),
                label: "Third".to_string(),
            },
        ];
        w.set_options_preserving_id(full_list);
        assert_eq!(
            w.value(),
            "uuid-42",
            "uuid preserved after set_options_preserving_id"
        );
        assert_eq!(
            w.display(),
            "Second (proper label)",
            "label updated to full label"
        );
    }

    #[test]
    fn set_options_preserving_id_falls_back_to_zero_when_not_found() {
        let mut w = SelectWidget::new();
        w.set_options(vec![SelectOption {
            id: "old".to_string(),
            label: "Old".to_string(),
        }]);
        let new_list = vec![
            SelectOption {
                id: "new-a".to_string(),
                label: "A".to_string(),
            },
            SelectOption {
                id: "new-b".to_string(),
                label: "B".to_string(),
            },
        ];
        w.set_options_preserving_id(new_list);
        assert_eq!(w.value(), "new-a");
    }

    #[test]
    fn confirm_closes_open_dropdown() {
        let mut w = SelectWidget::new();
        w.set_options(make_opts(2));
        w.open = true;
        w.confirm();
        assert!(!w.open);
    }

    #[test]
    fn filter_push_narrows_matches() {
        let mut w = SelectWidget::new();
        w.set_options(vec![
            SelectOption {
                id: "a".to_string(),
                label: "Apple".to_string(),
            },
            SelectOption {
                id: "b".to_string(),
                label: "Grape".to_string(),
            },
            SelectOption {
                id: "c".to_string(),
                label: "Apricot".to_string(),
            },
        ]);
        // 'p' matches "Apple" (has 'p') and "Apricot" (has 'p'), not "Grape" (has 'p' too!)
        // Use 'i' instead: "Apricot" has 'i', "Apple" has no 'i', "Grape" has no 'i'
        w.filter_push('i');
        let m = w.matches();
        assert_eq!(m.len(), 1, "only Apricot matches 'i'");
        assert_eq!(w.value(), "c", "first (only) match is Apricot");
    }

    #[test]
    fn filter_next_wraps_within_filtered_set() {
        let mut w = SelectWidget::new();
        w.set_options(vec![
            SelectOption {
                id: "id-0".to_string(),
                label: "Sword".to_string(),
            },
            SelectOption {
                id: "id-1".to_string(),
                label: "Tuna".to_string(),
            },
            SelectOption {
                id: "id-2".to_string(),
                label: "Squid".to_string(),
            },
        ]);
        // 's' matches "Sword" (idx 0) and "Squid" (idx 2), not "Tuna"
        w.filter_push('s');
        assert_eq!(w.value(), "id-0", "first match is Sword");
        w.next();
        assert_eq!(w.value(), "id-2", "second match is Squid");
        w.next();
        assert_eq!(w.value(), "id-0", "wraps back to first match");
    }

    #[test]
    fn filter_pop_widens_matches() {
        let mut w = SelectWidget::new();
        w.set_options(make_opts(3));
        w.filter_push('1'); // only "Label 1" matches
        assert_eq!(w.matches().len(), 1);
        w.filter_pop();
        assert_eq!(w.matches().len(), 3, "empty query matches all");
    }

    #[test]
    fn set_options_clears_query() {
        let mut w = SelectWidget::new();
        w.set_options(make_opts(3));
        w.filter_push('x');
        assert_eq!(w.query(), "x");
        w.set_options(make_opts(2));
        assert_eq!(w.query(), "", "set_options must clear query");
    }

    #[test]
    fn set_options_preserving_id_clears_query() {
        let mut w = SelectWidget::new();
        w.set_options(make_opts(3));
        w.filter_push('x');
        assert_eq!(w.query(), "x");
        w.set_options_preserving_id(make_opts(2));
        assert_eq!(w.query(), "", "set_options_preserving_id must clear query");
    }

    #[test]
    fn zero_match_value_and_display_empty() {
        let mut w = SelectWidget::new();
        w.set_options(make_opts(3));
        w.filter_push('z'); // no "Label N" contains 'z'
        assert_eq!(w.matches().len(), 0);
        assert_eq!(w.value(), "", "zero match → value is empty string");
        assert_eq!(w.display(), "", "zero match → display is empty string");
    }

    #[test]
    fn zero_match_next_and_prev_no_panic() {
        let mut w = SelectWidget::new();
        w.set_options(make_opts(3));
        w.filter_push('z'); // zero matches
        w.next(); // must not panic or index out of bounds
        w.prev(); // must not panic or index out of bounds
        assert_eq!(w.value(), "");
        assert_eq!(w.display(), "");
    }

    #[test]
    fn confirm_resolves_filtered_selection_to_raw_index() {
        let mut w = SelectWidget::new();
        w.set_options(vec![
            SelectOption {
                id: "id-x".to_string(),
                label: "Xenon".to_string(),
            },
            SelectOption {
                id: "id-a".to_string(),
                label: "Apple".to_string(),
            },
            SelectOption {
                id: "id-b".to_string(),
                label: "Banana".to_string(),
            },
        ]);
        // 'a' matches "Apple" (idx 1) and "Banana" (idx 2); focused=0 → "Apple"
        w.filter_push('a');
        assert_eq!(w.value(), "id-a");
        w.confirm();
        assert!(!w.open);
        assert_eq!(w.query(), "");
        // After confirm, focused resolved to raw index of "Apple" (idx 1)
        // With empty query, matches=[0,1,2], focused=1 → options[1] = "Apple"
        assert_eq!(
            w.value(),
            "id-a",
            "selection preserved after confirm+query clear"
        );
    }
}