travelagent 1.11.1

//! PR list browser UI — a minimal picker that shows `PrListItem` rows and
//! lets the user pick one to open.
//!
//! This module is pure presentation + input handling: it consumes a
//! pre-fetched slice of rows and emits high-level intents via `PrListEvent`.
//! The network-bound runner lives in `crate::pr_list_app`.
//!
//! # Client-side filters (Phase F)
//!
//! Users can narrow the list without re-hitting the forge via three filters:
//!
//! - `f a` — prompt for an assignee login; case-insensitive match against
//!   the row's `assignees` vec.
//! - `f r` — prompt for a reviewer login; case-insensitive match against
//!   `reviewers`.
//! - `f s` — cycle the state filter: All → Open → All. (The picker
//!   fetches open PRs from the forge, so Closed/Merged are not shown —
//!   a broader fetch is a Phase Z follow-up.)
//! - `f c` — clear every active filter.
//!
//! Active filters appear as a compact status-bar segment like
//! `[fa:john fr:alice fs:open]`; the segment is empty when nothing is set.
//!
//! ## `@me` sugar
//!
//! The literal token `@me` (case-insensitive) in an assignee or reviewer
//! prompt is substituted at commit time with the forge's signed-in user
//! login. Resolution happens once when the picker starts; if it fails
//! (offline, no token), `@me` falls through as a literal — which simply
//! matches nothing. The resolved login is stored on `PrListState::me_login`.

use ratatui::{
    Frame,
    layout::Rect,
    style::{Modifier, Style},
    text::{Line, Span},
    widgets::Paragraph,
};

use crate::theme::Theme;
use crate::ui::styles;
use travelagent_core::forge::{PrListItem, PrState};

/// State filter value. `All` is the default and means "match any state".
///
/// The picker fetches only open PRs from the forge today (see
/// `pr_list_app::run_picker`), so `Closed` / `Merged` entries would always
/// be empty — they are intentionally omitted here. Once the picker gains a
/// broader fetch (tracked as a Phase Z follow-up), extend this enum and
/// the cycle accordingly.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum StateFilter {
    #[default]
    All,
    Open,
}

impl StateFilter {
    /// Cycle to the next value in the order `All → Open → All`.
    pub fn cycle(self) -> Self {
        match self {
            StateFilter::All => StateFilter::Open,
            StateFilter::Open => StateFilter::All,
        }
    }

    fn matches(self, state: PrState) -> bool {
        match self {
            StateFilter::All => true,
            StateFilter::Open => state == PrState::Open,
        }
    }

    fn label(self) -> Option<&'static str> {
        match self {
            StateFilter::All => None,
            StateFilter::Open => Some("open"),
        }
    }
}

/// Client-side filter values applied against already-fetched rows.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct PrListFilters {
    /// Case-insensitive match against `PrListItem::assignees`.
    pub assignee: Option<String>,
    /// Case-insensitive match against `PrListItem::reviewers`.
    pub reviewer: Option<String>,
    pub state: StateFilter,
}

impl PrListFilters {
    /// Returns true when any filter is non-default.
    pub fn is_active(&self) -> bool {
        self.assignee.is_some() || self.reviewer.is_some() || self.state != StateFilter::All
    }

    /// Reset every field to its default (no filter).
    pub fn clear(&mut self) {
        self.assignee = None;
        self.reviewer = None;
        self.state = StateFilter::All;
    }

    fn matches(&self, item: &PrListItem) -> bool {
        if !self.state.matches(item.state) {
            return false;
        }
        // Login matching is case-insensitive: GitHub logins are
        // case-insensitive server-side but the API sometimes returns
        // mixed case (`John` vs `john`), and GitLab usernames are
        // lowercase-by-convention but not enforced. Both Claude and
        // grok-4-20-thinking flagged this in the post-F crew review.
        if let Some(ref want) = self.assignee
            && !item.assignees.iter().any(|a| a.eq_ignore_ascii_case(want))
        {
            return false;
        }
        if let Some(ref want) = self.reviewer
            && !item.reviewers.iter().any(|r| r.eq_ignore_ascii_case(want))
        {
            return false;
        }
        true
    }
}

/// Apply `filters` to `rows`, returning the subset that matches.
pub fn apply_filters(rows: &[PrListItem], filters: &PrListFilters) -> Vec<PrListItem> {
    rows.iter()
        .filter(|r| filters.matches(r))
        .cloned()
        .collect()
}

/// Compact status-bar segment for the active filters, e.g. `[fa:john fs:open]`.
/// Returns the empty string when no filter is active.
pub fn status_bar_segment(filters: &PrListFilters) -> String {
    if !filters.is_active() {
        return String::new();
    }
    let mut parts: Vec<String> = Vec::new();
    if let Some(ref a) = filters.assignee {
        parts.push(format!("fa:{a}"));
    }
    if let Some(ref r) = filters.reviewer {
        parts.push(format!("fr:{r}"));
    }
    if let Some(label) = filters.state.label() {
        parts.push(format!("fs:{label}"));
    }
    format!("[{}]", parts.join(" "))
}

/// Input mode for the picker. Most keys act globally in `Normal`; the `f` key
/// enters `FilterMenu` which consumes the next key as a sub-command; `a`/`r`
/// move on to `PromptingAssignee`/`PromptingReviewer` where every printable
/// key appends to a buffer until Enter commits or Esc cancels.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub enum Mode {
    #[default]
    Normal,
    /// Waiting on the second key of an `f X` chord.
    FilterMenu,
    /// Building an assignee string; commits to `filters.assignee` on Enter.
    PromptingAssignee(String),
    /// Building a reviewer string; commits to `filters.reviewer` on Enter.
    PromptingReviewer(String),
}

/// Cursor + viewport + filter state for the PR list picker.
#[derive(Debug, Default, Clone)]
pub struct PrListState {
    pub cursor: usize,
    pub scroll: usize,
    pub filters: PrListFilters,
    pub mode: Mode,
    /// Resolved signed-in user login; populated once by the runner before
    /// the event loop starts. When `Some`, the `@me` token in a filter
    /// prompt expands to this value. When `None`, `@me` is kept as a
    /// literal (which simply won't match any real login).
    pub me_login: Option<String>,
}

/// Expand the literal `@me` token (case-insensitive) to `me_login`, if
/// known. Any other string passes through unchanged. Returns `None` when
/// the input trims to empty, so callers can clear the filter via Enter on
/// an empty buffer.
fn resolve_me_token(raw: &str, me_login: Option<&str>) -> Option<String> {
    let trimmed = raw.trim();
    if trimmed.is_empty() {
        return None;
    }
    if trimmed.eq_ignore_ascii_case("@me")
        && let Some(me) = me_login
    {
        return Some(me.to_string());
    }
    Some(trimmed.to_string())
}

/// High-level intents produced by `handle_key`. The runner decides what to do
/// with them (pick a PR, quit, etc.).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PrListEvent {
    /// No state change; redraw only (or nothing).
    Nothing,
    /// State updated (cursor moved, etc.) — redraw.
    Redraw,
    /// User chose the PR at the current cursor.
    Select,
    /// User asked to quit the picker (Esc, q, Ctrl+C).
    Quit,
}

impl PrListState {
    pub fn new() -> Self {
        Self::default()
    }

    /// Clamp cursor and scroll to the current row count.
    pub fn clamp(&mut self, row_count: usize) {
        if row_count == 0 {
            self.cursor = 0;
            self.scroll = 0;
            return;
        }
        if self.cursor >= row_count {
            self.cursor = row_count - 1;
        }
        if self.scroll > self.cursor {
            self.scroll = self.cursor;
        }
    }

    fn ensure_visible(&mut self, viewport_rows: usize) {
        if viewport_rows == 0 {
            return;
        }
        if self.cursor < self.scroll {
            self.scroll = self.cursor;
        } else if self.cursor >= self.scroll + viewport_rows {
            self.scroll = self.cursor + 1 - viewport_rows;
        }
    }

    /// Reset cursor/scroll to the top. Used when the visible row count shrinks
    /// after a filter change so the cursor never points past the end.
    fn reset_cursor(&mut self) {
        self.cursor = 0;
        self.scroll = 0;
    }
}

/// Handle a single key event and return the resulting intent.
///
/// The caller renders, then calls this for each key, then renders again.
pub fn handle_key(
    key: crossterm::event::KeyEvent,
    state: &mut PrListState,
    row_count: usize,
    viewport_rows: usize,
) -> PrListEvent {
    use crossterm::event::{KeyCode, KeyModifiers};

    let is_ctrl_c = key.code == KeyCode::Char('c') && key.modifiers.contains(KeyModifiers::CONTROL);

    // Route keys by mode first so text input and in-prompt Ctrl+C don't
    // collide with navigation/quit. Prompts get first refusal on Ctrl+C
    // so users can cancel a typo mid-filter without losing the whole
    // picker (post-crew review 2026-05-02 fix). Quit semantics are
    // preserved for Normal / FilterMenu below.
    match std::mem::take(&mut state.mode) {
        Mode::FilterMenu => return handle_filter_menu_key(key, state),
        Mode::PromptingAssignee(buf) => {
            if is_ctrl_c {
                // Abandon the buffer, return to Normal mode. Picker stays up.
                return PrListEvent::Redraw;
            }
            return handle_prompt_key(key, state, buf, PromptKind::Assignee);
        }
        Mode::PromptingReviewer(buf) => {
            if is_ctrl_c {
                return PrListEvent::Redraw;
            }
            return handle_prompt_key(key, state, buf, PromptKind::Reviewer);
        }
        Mode::Normal => {
            // Fall through to the normal key table below.
        }
    }

    // Outside a prompt, Ctrl+C still quits.
    if is_ctrl_c {
        return PrListEvent::Quit;
    }

    match key.code {
        KeyCode::Esc | KeyCode::Char('q') => PrListEvent::Quit,
        KeyCode::Char('f') => {
            state.mode = Mode::FilterMenu;
            PrListEvent::Redraw
        }
        KeyCode::Enter | KeyCode::Char('o') => {
            if row_count == 0 {
                PrListEvent::Nothing
            } else {
                PrListEvent::Select
            }
        }
        KeyCode::Down | KeyCode::Char('j') => {
            if row_count == 0 || state.cursor + 1 >= row_count {
                return PrListEvent::Nothing;
            }
            state.cursor += 1;
            state.ensure_visible(viewport_rows);
            PrListEvent::Redraw
        }
        KeyCode::Up | KeyCode::Char('k') => {
            if state.cursor == 0 {
                return PrListEvent::Nothing;
            }
            state.cursor -= 1;
            state.ensure_visible(viewport_rows);
            PrListEvent::Redraw
        }
        KeyCode::Char('g') => {
            if state.cursor == 0 {
                return PrListEvent::Nothing;
            }
            state.cursor = 0;
            state.ensure_visible(viewport_rows);
            PrListEvent::Redraw
        }
        KeyCode::Char('G') => {
            if row_count == 0 {
                return PrListEvent::Nothing;
            }
            let last = row_count - 1;
            if state.cursor == last {
                return PrListEvent::Nothing;
            }
            state.cursor = last;
            state.ensure_visible(viewport_rows);
            PrListEvent::Redraw
        }
        KeyCode::PageDown | KeyCode::Char('d') => {
            if row_count == 0 {
                return PrListEvent::Nothing;
            }
            let step = viewport_rows.max(1);
            state.cursor = (state.cursor + step).min(row_count - 1);
            state.ensure_visible(viewport_rows);
            PrListEvent::Redraw
        }
        KeyCode::PageUp | KeyCode::Char('u') => {
            if state.cursor == 0 {
                return PrListEvent::Nothing;
            }
            let step = viewport_rows.max(1);
            state.cursor = state.cursor.saturating_sub(step);
            state.ensure_visible(viewport_rows);
            PrListEvent::Redraw
        }
        _ => PrListEvent::Nothing,
    }
}

#[derive(Copy, Clone)]
enum PromptKind {
    Assignee,
    Reviewer,
}

fn handle_filter_menu_key(key: crossterm::event::KeyEvent, state: &mut PrListState) -> PrListEvent {
    use crossterm::event::KeyCode;
    // `mode` was already taken; leave it as `Normal` for anything that doesn't
    // transition further.
    match key.code {
        KeyCode::Char('a') => {
            state.mode = Mode::PromptingAssignee(String::new());
            PrListEvent::Redraw
        }
        KeyCode::Char('r') => {
            state.mode = Mode::PromptingReviewer(String::new());
            PrListEvent::Redraw
        }
        KeyCode::Char('s') => {
            state.filters.state = state.filters.state.cycle();
            state.reset_cursor();
            PrListEvent::Redraw
        }
        KeyCode::Char('c') => {
            state.filters.clear();
            state.reset_cursor();
            PrListEvent::Redraw
        }
        // Esc or any other key cancels the chord silently.
        _ => PrListEvent::Redraw,
    }
}

fn handle_prompt_key(
    key: crossterm::event::KeyEvent,
    state: &mut PrListState,
    mut buf: String,
    kind: PromptKind,
) -> PrListEvent {
    use crossterm::event::KeyCode;
    match key.code {
        KeyCode::Esc => {
            // Cancel: discard buf, stay in Normal mode.
            PrListEvent::Redraw
        }
        KeyCode::Enter => {
            let value = resolve_me_token(&buf, state.me_login.as_deref());
            match kind {
                PromptKind::Assignee => state.filters.assignee = value,
                PromptKind::Reviewer => state.filters.reviewer = value,
            }
            state.reset_cursor();
            PrListEvent::Redraw
        }
        KeyCode::Backspace => {
            buf.pop();
            match kind {
                PromptKind::Assignee => state.mode = Mode::PromptingAssignee(buf),
                PromptKind::Reviewer => state.mode = Mode::PromptingReviewer(buf),
            }
            PrListEvent::Redraw
        }
        KeyCode::Char(c) => {
            buf.push(c);
            match kind {
                PromptKind::Assignee => state.mode = Mode::PromptingAssignee(buf),
                PromptKind::Reviewer => state.mode = Mode::PromptingReviewer(buf),
            }
            PrListEvent::Redraw
        }
        _ => {
            // Restore mode for any non-matching key so the prompt stays active.
            match kind {
                PromptKind::Assignee => state.mode = Mode::PromptingAssignee(buf),
                PromptKind::Reviewer => state.mode = Mode::PromptingReviewer(buf),
            }
            PrListEvent::Nothing
        }
    }
}

/// Build a single styled row for a PR entry.
pub fn row_line(item: &PrListItem, theme: &Theme, selected: bool) -> Line<'static> {
    let marker = if item.is_draft { "D" } else { " " };
    let state_label = match item.state {
        PrState::Open => "open",
        PrState::Closed => "closed",
        PrState::Merged => "merged",
    };
    let state_color = match item.state {
        PrState::Open => theme.pending,
        PrState::Closed => theme.fg_dim,
        PrState::Merged => theme.reviewed,
    };
    let prefix = format!(" {marker} #{:<6} ", item.number);
    let middle = truncate_col(&item.title, 60);
    let suffix = format!(" by {}  ", item.author);
    let state_part = format!("[{state_label}]");

    let mut spans = vec![
        Span::styled(prefix, Style::default().fg(theme.fg_secondary)),
        Span::styled(middle, Style::default().add_modifier(Modifier::BOLD)),
        Span::styled(suffix, Style::default().fg(theme.fg_secondary)),
        Span::styled(state_part, Style::default().fg(state_color)),
    ];

    if selected {
        let sel = styles::selected_style(theme);
        for span in &mut spans {
            span.style = span.style.patch(sel);
        }
    }
    Line::from(spans)
}

fn truncate_col(s: &str, max: usize) -> String {
    if s.chars().count() <= max {
        return format!("{s:<max$}");
    }
    let mut out: String = s.chars().take(max.saturating_sub(1)).collect();
    out.push('\u{2026}');
    out
}

/// Render the PR list into `area`.
///
/// Client-side filters are applied here so callers keep passing the unfiltered
/// `rows` slice; the renderer computes a filtered view internally.
pub fn render(
    frame: &mut Frame,
    area: Rect,
    rows: &[PrListItem],
    state: &mut PrListState,
    theme: &Theme,
    header: &str,
) {
    let filtered = apply_filters(rows, &state.filters);

    let segment = status_bar_segment(&state.filters);
    let header_suffix = if segment.is_empty() {
        String::new()
    } else {
        format!("  {segment}")
    };
    let header_line = Line::from(vec![Span::styled(
        format!("  {header}{header_suffix}  (j/k move, Enter open, f filter, q cancel)"),
        Style::default()
            .fg(theme.fg_secondary)
            .add_modifier(Modifier::BOLD),
    )]);

    let mut lines: Vec<Line<'static>> = Vec::with_capacity(filtered.len() + 3);
    lines.push(header_line);
    // Show the in-progress filter chord / prompt on the second line, when any.
    if let Some(prompt) = mode_prompt_line(&state.mode, theme) {
        lines.push(prompt);
    } else {
        lines.push(Line::from(""));
    }

    state.clamp(filtered.len());
    let viewport = (area.height as usize).saturating_sub(2);

    if filtered.is_empty() {
        lines.push(Line::from(Span::styled(
            "  No PRs match the current filter".to_string(),
            styles::dim_style(theme),
        )));
    } else {
        state.ensure_visible(viewport);
        let end = (state.scroll + viewport).min(filtered.len());
        for (idx, item) in filtered[state.scroll..end].iter().enumerate() {
            let absolute = state.scroll + idx;
            lines.push(row_line(item, theme, absolute == state.cursor));
        }
    }

    let paragraph = Paragraph::new(lines).style(styles::panel_style(theme));
    frame.render_widget(paragraph, area);
}

fn mode_prompt_line(mode: &Mode, theme: &Theme) -> Option<Line<'static>> {
    let text = match mode {
        Mode::Normal => return None,
        Mode::FilterMenu => "  filter: [a]ssignee  [r]eviewer  [s]tate  [c]lear".to_string(),
        Mode::PromptingAssignee(buf) => format!("  assignee (try @me): {buf}_"),
        Mode::PromptingReviewer(buf) => format!("  reviewer (try @me): {buf}_"),
    };
    Some(Line::from(Span::styled(
        text,
        Style::default().fg(theme.fg_secondary),
    )))
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::Utc;
    use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
    use travelagent_core::forge::{PrListItem, PrState};

    fn item(n: u64, title: &str, state: PrState) -> PrListItem {
        PrListItem {
            number: n,
            title: title.to_string(),
            author: "alice".to_string(),
            state,
            is_draft: false,
            base_branch: "main".to_string(),
            head_branch: "feature".to_string(),
            updated_at: Utc::now(),
            comment_count: 0,
            has_review_requested_from_me: false,
            assignees: vec![],
            reviewers: vec![],
        }
    }

    fn key(code: KeyCode) -> KeyEvent {
        KeyEvent::new(code, KeyModifiers::empty())
    }

    #[test]
    fn j_moves_cursor_down_and_clamps_at_end() {
        let mut s = PrListState::new();
        let ev = handle_key(key(KeyCode::Char('j')), &mut s, 3, 10);
        assert_eq!(ev, PrListEvent::Redraw);
        assert_eq!(s.cursor, 1);

        handle_key(key(KeyCode::Char('j')), &mut s, 3, 10);
        handle_key(key(KeyCode::Char('j')), &mut s, 3, 10);
        assert_eq!(s.cursor, 2); // clamped

        let ev = handle_key(key(KeyCode::Char('j')), &mut s, 3, 10);
        assert_eq!(ev, PrListEvent::Nothing);
        assert_eq!(s.cursor, 2);
    }

    #[test]
    fn k_moves_cursor_up_and_stops_at_zero() {
        let mut s = PrListState::new();
        s.cursor = 2;
        handle_key(key(KeyCode::Char('k')), &mut s, 3, 10);
        assert_eq!(s.cursor, 1);
        handle_key(key(KeyCode::Char('k')), &mut s, 3, 10);
        assert_eq!(s.cursor, 0);
        let ev = handle_key(key(KeyCode::Char('k')), &mut s, 3, 10);
        assert_eq!(ev, PrListEvent::Nothing);
    }

    #[test]
    fn enter_selects_when_non_empty() {
        let mut s = PrListState::new();
        let ev = handle_key(key(KeyCode::Enter), &mut s, 3, 10);
        assert_eq!(ev, PrListEvent::Select);

        let ev = handle_key(key(KeyCode::Enter), &mut s, 0, 10);
        assert_eq!(ev, PrListEvent::Nothing);
    }

    #[test]
    fn esc_and_q_quit() {
        let mut s = PrListState::new();
        assert_eq!(
            handle_key(key(KeyCode::Esc), &mut s, 3, 10),
            PrListEvent::Quit
        );
        assert_eq!(
            handle_key(key(KeyCode::Char('q')), &mut s, 3, 10),
            PrListEvent::Quit
        );
    }

    #[test]
    fn ctrl_c_quits() {
        let mut s = PrListState::new();
        let ev = handle_key(
            KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),
            &mut s,
            3,
            10,
        );
        assert_eq!(ev, PrListEvent::Quit);
    }

    #[test]
    fn g_jumps_to_top_capital_g_jumps_to_bottom() {
        let mut s = PrListState::new();
        s.cursor = 3;
        handle_key(key(KeyCode::Char('g')), &mut s, 10, 5);
        assert_eq!(s.cursor, 0);

        handle_key(key(KeyCode::Char('G')), &mut s, 10, 5);
        assert_eq!(s.cursor, 9);
    }

    #[test]
    fn page_down_moves_by_viewport() {
        let mut s = PrListState::new();
        handle_key(key(KeyCode::PageDown), &mut s, 20, 5);
        assert_eq!(s.cursor, 5);
        handle_key(key(KeyCode::Char('d')), &mut s, 20, 5);
        assert_eq!(s.cursor, 10);
    }

    #[test]
    fn page_up_moves_by_viewport() {
        let mut s = PrListState::new();
        s.cursor = 15;
        handle_key(key(KeyCode::PageUp), &mut s, 20, 5);
        assert_eq!(s.cursor, 10);
        handle_key(key(KeyCode::Char('u')), &mut s, 20, 5);
        assert_eq!(s.cursor, 5);
    }

    #[test]
    fn ensure_visible_scrolls_down_when_cursor_exits_viewport() {
        let mut s = PrListState::new();
        // Start at 0, jump to row 12 with viewport 5.
        s.cursor = 12;
        s.ensure_visible(5);
        // Header is last visible: scroll = 12 + 1 - 5 = 8
        assert_eq!(s.scroll, 8);
    }

    #[test]
    fn ensure_visible_scrolls_up_when_cursor_above_viewport() {
        let mut s = PrListState::new();
        s.scroll = 8;
        s.cursor = 3;
        s.ensure_visible(5);
        assert_eq!(s.scroll, 3);
    }

    #[test]
    fn clamp_handles_empty_and_shrink() {
        let mut s = PrListState::new();
        s.cursor = 10;
        s.scroll = 5;
        s.clamp(0);
        assert_eq!(s.cursor, 0);
        assert_eq!(s.scroll, 0);

        s.cursor = 10;
        s.clamp(3);
        assert_eq!(s.cursor, 2);
    }

    #[test]
    fn row_line_shows_draft_marker_and_state() {
        let theme = Theme::dark();
        let mut it = item(42, "feat: add login", PrState::Open);
        it.is_draft = true;
        let line = row_line(&it, &theme, false);
        let text: String = line.spans.iter().map(|s| s.content.as_ref()).collect();
        assert!(text.contains('D'));
        assert!(text.contains("#42"));
        assert!(text.contains("feat: add login"));
        assert!(text.contains("[open]"));
    }

    #[test]
    fn truncate_col_adds_ellipsis_when_too_long() {
        let s = truncate_col("a very long title that overflows", 10);
        assert!(s.chars().count() <= 10);
        assert!(s.ends_with('\u{2026}'));
    }

    #[test]
    fn truncate_col_pads_short_values_to_width() {
        let s = truncate_col("hi", 5);
        assert_eq!(s, "hi   ");
    }

    // ---- Phase F: client-side filter tests ----

    fn with_assignees(mut pr: PrListItem, assignees: &[&str]) -> PrListItem {
        pr.assignees = assignees.iter().map(|s| s.to_string()).collect();
        pr
    }

    fn with_reviewers(mut pr: PrListItem, reviewers: &[&str]) -> PrListItem {
        pr.reviewers = reviewers.iter().map(|s| s.to_string()).collect();
        pr
    }

    #[test]
    fn filter_by_assignee_exact_match() {
        let rows = vec![
            with_assignees(item(1, "a", PrState::Open), &["john"]),
            with_assignees(item(2, "b", PrState::Open), &["bob"]),
        ];
        let filters = PrListFilters {
            assignee: Some("john".to_string()),
            ..Default::default()
        };
        let got = apply_filters(&rows, &filters);
        assert_eq!(got.len(), 1);
        assert_eq!(got[0].number, 1);
    }

    #[test]
    fn filter_by_assignee_is_case_insensitive() {
        // Regression: GitHub returns `John` and the user types `john` —
        // previously this silently matched nothing.
        let rows = vec![with_assignees(item(1, "a", PrState::Open), &["John"])];
        let filters = PrListFilters {
            assignee: Some("john".to_string()),
            ..Default::default()
        };
        let got = apply_filters(&rows, &filters);
        assert_eq!(got.len(), 1, "lowercased filter matches mixed-case login");
    }

    #[test]
    fn filter_by_reviewer_is_case_insensitive() {
        let rows = vec![with_reviewers(item(1, "a", PrState::Open), &["ALICE"])];
        let filters = PrListFilters {
            reviewer: Some("alice".to_string()),
            ..Default::default()
        };
        let got = apply_filters(&rows, &filters);
        assert_eq!(got.len(), 1);
    }

    #[test]
    fn filter_by_reviewer_exact_match() {
        let rows = vec![
            with_reviewers(item(1, "a", PrState::Open), &["alice"]),
            with_reviewers(item(2, "b", PrState::Open), &["carol"]),
        ];
        let filters = PrListFilters {
            reviewer: Some("alice".to_string()),
            ..Default::default()
        };
        let got = apply_filters(&rows, &filters);
        assert_eq!(got.len(), 1);
        assert_eq!(got[0].number, 1);
    }

    #[test]
    fn filter_by_state_open_excludes_closed() {
        // The picker only ever fetches open PRs, but the client-side filter
        // is still defensive: if a row with a non-Open state slipped in
        // (e.g. a cached payload from a future broader fetch),
        // `StateFilter::Open` must exclude it.
        let rows = vec![
            item(1, "open", PrState::Open),
            item(2, "closed", PrState::Closed),
            item(3, "merged", PrState::Merged),
        ];
        let filters = PrListFilters {
            state: StateFilter::Open,
            ..Default::default()
        };
        let got = apply_filters(&rows, &filters);
        assert_eq!(got.len(), 1);
        assert_eq!(got[0].number, 1);
    }

    #[test]
    fn filter_clear_restores_full_list() {
        let rows = vec![
            with_assignees(item(1, "a", PrState::Open), &["john"]),
            item(2, "b", PrState::Closed),
        ];
        let mut filters = PrListFilters {
            assignee: Some("john".to_string()),
            state: StateFilter::Open,
            ..Default::default()
        };
        assert_eq!(apply_filters(&rows, &filters).len(), 1);
        filters.clear();
        assert!(!filters.is_active());
        assert_eq!(apply_filters(&rows, &filters).len(), rows.len());
    }

    #[test]
    fn status_bar_segment_empty_when_no_filter() {
        let filters = PrListFilters::default();
        assert_eq!(status_bar_segment(&filters), "");
    }

    #[test]
    fn status_bar_segment_shows_active_filters() {
        let filters = PrListFilters {
            assignee: Some("john".to_string()),
            reviewer: Some("alice".to_string()),
            state: StateFilter::Open,
        };
        assert_eq!(status_bar_segment(&filters), "[fa:john fr:alice fs:open]");
    }

    // ---- Keybinding wiring ----

    #[test]
    fn f_s_cycles_state_filter() {
        let mut s = PrListState::new();
        // f → enters FilterMenu
        handle_key(key(KeyCode::Char('f')), &mut s, 0, 10);
        assert_eq!(s.mode, Mode::FilterMenu);
        // s → cycles state to Open; mode returns to Normal
        handle_key(key(KeyCode::Char('s')), &mut s, 0, 10);
        assert_eq!(s.mode, Mode::Normal);
        assert_eq!(s.filters.state, StateFilter::Open);

        // Second cycle wraps back to `All` (we intentionally only expose
        // `Open` / `All` today — picker fetches open PRs only, so
        // `Closed` / `Merged` would always be empty. See `StateFilter` docs.)
        handle_key(key(KeyCode::Char('f')), &mut s, 0, 10);
        handle_key(key(KeyCode::Char('s')), &mut s, 0, 10);
        assert_eq!(s.filters.state, StateFilter::All);
    }

    #[test]
    fn f_a_then_input_then_enter_sets_assignee() {
        let mut s = PrListState::new();
        handle_key(key(KeyCode::Char('f')), &mut s, 0, 10);
        handle_key(key(KeyCode::Char('a')), &mut s, 0, 10);
        assert_eq!(s.mode, Mode::PromptingAssignee(String::new()));

        for c in "john".chars() {
            handle_key(key(KeyCode::Char(c)), &mut s, 0, 10);
        }
        handle_key(key(KeyCode::Enter), &mut s, 0, 10);
        assert_eq!(s.filters.assignee.as_deref(), Some("john"));
        assert_eq!(s.mode, Mode::Normal);
    }

    #[test]
    fn f_c_clears_filters() {
        let mut s = PrListState::new();
        s.filters.assignee = Some("john".to_string());
        s.filters.state = StateFilter::Open;
        handle_key(key(KeyCode::Char('f')), &mut s, 0, 10);
        handle_key(key(KeyCode::Char('c')), &mut s, 0, 10);
        assert!(!s.filters.is_active());
    }

    // ---- @me sugar ----

    #[test]
    fn resolve_me_token_expands_literal_at_me() {
        assert_eq!(
            resolve_me_token("@me", Some("john")),
            Some("john".to_string())
        );
        assert_eq!(
            resolve_me_token("  @ME  ", Some("john")),
            Some("john".to_string()),
            "case-insensitive and whitespace-trimmed"
        );
    }

    #[test]
    fn resolve_me_token_passes_through_regular_login() {
        assert_eq!(
            resolve_me_token("alice", Some("john")),
            Some("alice".to_string())
        );
    }

    #[test]
    fn resolve_me_token_keeps_literal_when_me_unknown() {
        // Unresolved @me falls through as a literal; it won't match any
        // real login, which is the right behaviour for offline use.
        assert_eq!(
            resolve_me_token("@me", None),
            Some("@me".to_string()),
            "unknown me falls through unchanged"
        );
    }

    #[test]
    fn resolve_me_token_returns_none_for_empty_buffer() {
        assert_eq!(resolve_me_token("", Some("john")), None);
        assert_eq!(resolve_me_token("   ", Some("john")), None);
    }

    #[test]
    fn f_a_at_me_expands_to_resolved_login() {
        let mut s = PrListState::new();
        s.me_login = Some("john".to_string());
        handle_key(key(KeyCode::Char('f')), &mut s, 0, 10);
        handle_key(key(KeyCode::Char('a')), &mut s, 0, 10);
        for c in "@me".chars() {
            handle_key(key(KeyCode::Char(c)), &mut s, 0, 10);
        }
        handle_key(key(KeyCode::Enter), &mut s, 0, 10);
        assert_eq!(s.filters.assignee.as_deref(), Some("john"));
    }

    #[test]
    fn f_r_at_me_expands_to_resolved_login() {
        let mut s = PrListState::new();
        s.me_login = Some("john".to_string());
        handle_key(key(KeyCode::Char('f')), &mut s, 0, 10);
        handle_key(key(KeyCode::Char('r')), &mut s, 0, 10);
        for c in "@me".chars() {
            handle_key(key(KeyCode::Char(c)), &mut s, 0, 10);
        }
        handle_key(key(KeyCode::Enter), &mut s, 0, 10);
        assert_eq!(s.filters.reviewer.as_deref(), Some("john"));
    }

    #[test]
    fn esc_in_prompt_cancels_without_setting() {
        let mut s = PrListState::new();
        handle_key(key(KeyCode::Char('f')), &mut s, 0, 10);
        handle_key(key(KeyCode::Char('r')), &mut s, 0, 10);
        handle_key(key(KeyCode::Char('x')), &mut s, 0, 10);
        handle_key(key(KeyCode::Esc), &mut s, 0, 10);
        assert!(s.filters.reviewer.is_none());
        assert_eq!(s.mode, Mode::Normal);
    }

    // ---- CRITICAL regression (post-crew review 2026-05-02): filtered-view
    // selection. The event loop previously passed `rows.len()` (unfiltered)
    // to `handle_key` and indexed `rows[state.cursor]` on Select, which
    // opened the wrong PR after any filter chord. Both tests below pin the
    // invariant that selection must honor the filtered view.

    #[test]
    fn selection_uses_filtered_view_after_assignee_filter() {
        // Build an unfiltered list of 3 PRs where only #2 matches the filter.
        let rows = vec![
            with_assignees(item(1, "unrelated", PrState::Open), &["alice"]),
            with_assignees(item(2, "mine", PrState::Open), &["john"]),
            with_assignees(item(3, "other", PrState::Open), &["bob"]),
        ];
        let filters = PrListFilters {
            assignee: Some("john".into()),
            ..Default::default()
        };
        let visible = apply_filters(&rows, &filters);
        assert_eq!(visible.len(), 1, "exactly one row matches john");

        // Cursor at 0 in the filtered view must point at PR #2, not rows[0].
        let cursor = 0usize;
        let selected = visible.get(cursor).expect("cursor within filtered bounds");
        assert_eq!(
            selected.number, 2,
            "Select must index the filtered view, not the unfiltered rows slice"
        );
        // Counter-example: indexing rows[cursor] directly would return PR #1.
        assert_ne!(
            rows[cursor].number, 2,
            "sanity — this is exactly the bug the fix prevents"
        );
    }

    #[test]
    fn ctrl_c_in_assignee_prompt_cancels_prompt_not_picker() {
        let mut s = PrListState::new();
        handle_key(key(KeyCode::Char('f')), &mut s, 0, 10);
        handle_key(key(KeyCode::Char('a')), &mut s, 0, 10);
        for c in "jo".chars() {
            handle_key(key(KeyCode::Char(c)), &mut s, 0, 10);
        }
        // Mid-buffer Ctrl+C must NOT quit the whole picker; it abandons
        // the buffer and returns to Normal mode so the user can try again.
        let ev = handle_key(
            KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),
            &mut s,
            0,
            10,
        );
        assert_eq!(ev, PrListEvent::Redraw, "Ctrl+C in prompt must not Quit");
        assert_eq!(s.mode, Mode::Normal, "prompt should have exited");
        assert!(
            s.filters.assignee.is_none(),
            "buffer must not be committed on cancel"
        );
    }

    #[test]
    fn ctrl_c_in_reviewer_prompt_cancels_prompt_not_picker() {
        let mut s = PrListState::new();
        handle_key(key(KeyCode::Char('f')), &mut s, 0, 10);
        handle_key(key(KeyCode::Char('r')), &mut s, 0, 10);
        handle_key(key(KeyCode::Char('x')), &mut s, 0, 10);
        let ev = handle_key(
            KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),
            &mut s,
            0,
            10,
        );
        assert_eq!(ev, PrListEvent::Redraw);
        assert_eq!(s.mode, Mode::Normal);
        assert!(s.filters.reviewer.is_none());
    }

    #[test]
    fn ctrl_c_in_normal_mode_still_quits() {
        // Sanity — outside a prompt, Ctrl+C must still exit the picker.
        let mut s = PrListState::new();
        let ev = handle_key(
            KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),
            &mut s,
            3,
            10,
        );
        assert_eq!(ev, PrListEvent::Quit);
    }

    #[test]
    fn selection_noops_when_cursor_past_filtered_end() {
        // Filter produces zero matches; cursor at 0 should not open any PR.
        let rows = vec![item(1, "a", PrState::Open), item(2, "b", PrState::Open)];
        let filters = PrListFilters {
            assignee: Some("nobody".into()),
            ..Default::default()
        };
        let visible = apply_filters(&rows, &filters);
        // Empty filtered view → event loop's `visible.get(cursor)` returns
        // None and falls through to `continue`, so Select is a no-op.
        assert!(
            visible.is_empty(),
            "filter matches nothing; Select must not open any row"
        );
    }
}