//! The main event loop. [`MenuRunner`] wraps any [`Menu`]
//! implementation, drives the action/event channel loop,
//! and broadcasts state changes. Frontends never mutate
//! state directly. They send actions and react to events.

use std::sync::Arc;

use indexmap::IndexSet;
use tokio::sync::{broadcast, mpsc};
use tracing::{debug, info, trace};

use crate::debounce::{DebouncedDispatcher, hook_response_to_action};
use crate::error::PiklError;
use crate::event::{Action, ColumnHeader, MenuEvent, MenuResult, Mode, ViewState, VisibleItem};
use crate::hook::{HookEvent, HookHandler};
use crate::model::traits::MutableMenu;
use crate::navigation::Viewport;
use serde_json::Value;

/// Result of applying a single action to the menu state.
/// The run loop uses this to decide what to broadcast.
#[derive(Debug)]
pub enum ActionOutcome {
    /// State changed, broadcast to subscribers.
    Broadcast,
    /// User confirmed a selection.
    Selected { items: Vec<(Value, usize)> },
    /// User cancelled.
    Cancelled,
    /// Menu closed by hook command.
    Closed,
    /// User quicklisted the filtered items.
    Quicklist { items: Vec<(Value, usize)> },
    /// Nothing happened (e.g. confirm on empty list).
    NoOp,
}

/// Tracks multi-select state: which items are selected (by
/// original index), with undo/redo support.
pub struct SelectionState {
    selected: IndexSet<usize>,
    undo_stack: Vec<IndexSet<usize>>,
    redo_stack: Vec<IndexSet<usize>>,
    multi_enabled: bool,
    selection_order: bool,
}

impl SelectionState {
    fn new() -> Self {
        Self {
            selected: IndexSet::new(),
            undo_stack: Vec::new(),
            redo_stack: Vec::new(),
            multi_enabled: false,
            selection_order: false,
        }
    }

    fn push_undo(&mut self) {
        self.undo_stack.push(self.selected.clone());
        self.redo_stack.clear();
    }

    /// Toggle an item in/out of the selection set.
    pub fn toggle(&mut self, original_index: usize) {
        self.push_undo();
        if !self.selected.shift_remove(&original_index) {
            self.selected.insert(original_index);
        }
    }

    /// Force-select a range of items (no toggle).
    pub fn select_range(&mut self, indices: impl Iterator<Item = usize>) {
        self.push_undo();
        for idx in indices {
            self.selected.insert(idx);
        }
    }

    /// Select all the given items.
    pub fn select_all(&mut self, indices: impl Iterator<Item = usize>) {
        self.push_undo();
        for idx in indices {
            self.selected.insert(idx);
        }
    }

    /// Clear all selections.
    pub fn clear(&mut self) {
        if self.selected.is_empty() {
            return;
        }
        self.push_undo();
        self.selected.clear();
    }

    /// Undo the last selection change.
    pub fn undo(&mut self) {
        if let Some(prev) = self.undo_stack.pop() {
            self.redo_stack
                .push(std::mem::replace(&mut self.selected, prev));
        }
    }

    /// Redo a previously undone selection change.
    pub fn redo(&mut self) {
        if let Some(next) = self.redo_stack.pop() {
            self.undo_stack
                .push(std::mem::replace(&mut self.selected, next));
        }
    }

    pub fn is_selected(&self, original_index: usize) -> bool {
        self.selected.contains(&original_index)
    }

    pub fn count(&self) -> usize {
        self.selected.len()
    }

    /// Items sorted by original index (input order).
    pub fn ordered_items(&self) -> Vec<usize> {
        let mut items: Vec<usize> = self.selected.iter().copied().collect();
        items.sort_unstable();
        items
    }

    /// Items in insertion order (the order they were selected).
    pub fn insertion_ordered(&self) -> Vec<usize> {
        self.selected.iter().copied().collect()
    }
}

/// The menu engine. Wraps any [`Menu`] implementation and
/// drives it with an action/event channel loop. Create one,
/// grab the action sender and event subscriber, then call
/// [`MenuRunner::run`] to start the event loop.
pub struct MenuRunner<M: MutableMenu> {
    menu: M,
    viewport: Viewport,
    filter_text: Arc<str>,
    mode: Mode,
    action_rx: mpsc::Receiver<Action>,
    event_tx: broadcast::Sender<MenuEvent>,
    dispatcher: Option<DebouncedDispatcher>,
    previous_cursor: Option<usize>,
    generation: u64,
    selection: SelectionState,
    visual_anchor: Option<usize>,
}

impl<M: MutableMenu> MenuRunner<M> {
    /// Create a menu runner wrapping the given menu backend.
    /// Returns the runner and an action sender. Call
    /// [`subscribe`](Self::subscribe) to get an event handle,
    /// then [`run`](Self::run) to start the event loop.
    pub fn new(menu: M) -> (Self, mpsc::Sender<Action>) {
        let (action_tx, action_rx) = mpsc::channel(256);
        // 1024 slots: large enough that a burst of rapid state changes
        // (e.g. streaming AddItems + filter updates) won't cause lag for
        // subscribers. If a subscriber does fall behind, it gets a Lagged
        // error and can catch up from the next StateChanged.
        let (event_tx, _) = broadcast::channel(1024);
        let runner = Self {
            menu,
            viewport: Viewport::new(),
            filter_text: Arc::from(""),
            mode: Mode::default(),
            action_rx,
            event_tx,
            dispatcher: None,
            previous_cursor: None,
            generation: 0,
            selection: SelectionState::new(),
            visual_anchor: None,
        };
        (runner, action_tx)
    }

    /// Subscribe to menu events. Returns a broadcast receiver
    /// that gets state changes, selections, and cancellations.
    pub fn subscribe(&self) -> broadcast::Receiver<MenuEvent> {
        self.event_tx.subscribe()
    }

    /// Set a hook handler. Wraps it in a DebouncedDispatcher
    /// with no debounce (all events fire immediately). Use
    /// [`set_dispatcher`] for custom debounce settings.
    pub fn set_hook_handler(
        &mut self,
        handler: Arc<dyn HookHandler>,
        action_tx: mpsc::Sender<Action>,
    ) {
        let dispatcher = DebouncedDispatcher::new(handler, action_tx);
        self.dispatcher = Some(dispatcher);
    }

    /// Set a hook handler with a pre-configured dispatcher.
    pub fn set_dispatcher(&mut self, dispatcher: DebouncedDispatcher) {
        self.dispatcher = Some(dispatcher);
    }

    /// Enable multi-select mode.
    pub fn set_multi(&mut self, enabled: bool) {
        self.selection.multi_enabled = enabled;
    }

    /// Enable selection-order output (insertion order instead
    /// of input order).
    pub fn set_selection_order(&mut self, enabled: bool) {
        self.selection.selection_order = enabled;
    }

    /// Re-run the filter against all items with the current
    /// filter text. Updates the viewport with the new count.
    fn run_filter(&mut self) {
        let start = std::time::Instant::now();
        self.menu.apply_filter(&self.filter_text);
        let matched = self.menu.filtered_count();
        let total = self.menu.total();
        let duration_us = start.elapsed().as_micros() as u64;
        debug!(
            filter = %self.filter_text,
            matched,
            total,
            duration_us,
            "filter applied"
        );
        self.viewport.set_filtered_count(matched);
    }

    /// Build a [`ViewState`] snapshot from the current filter
    /// results and viewport position.
    fn build_view_state(&mut self) -> ViewState {
        self.generation += 1;
        let range = self.viewport.visible_range();
        let has_columns = self.menu.column_config().is_some();
        let visible_items: Vec<VisibleItem> = range
            .clone()
            .filter_map(|i| {
                self.menu.filtered_label(i).map(|label| {
                    let formatted_text = self.menu.formatted_label(i);
                    let orig_idx = self.menu.original_index(i).unwrap_or(0);
                    let column_values = if has_columns {
                        self.menu.column_values(i)
                    } else {
                        None
                    };
                    VisibleItem {
                        label: label.to_string(),
                        formatted_text,
                        index: i,
                        selected: self.selection.is_selected(orig_idx),
                        column_values,
                    }
                })
            })
            .collect();

        // Compute column headers with widths if table mode is active
        let columns = self.menu.column_config().map(|config| {
            config
                .columns
                .iter()
                .enumerate()
                .map(|(col_idx, col_def)| {
                    let header_len = col_def.display_name.len();
                    let max_cell = visible_items
                        .iter()
                        .filter_map(|vi| {
                            vi.column_values
                                .as_ref()
                                .and_then(|cv| cv.get(col_idx))
                                .map(|s| s.len())
                        })
                        .max()
                        .unwrap_or(0);
                    let width = header_len.max(max_cell).min(60) as u16;
                    ColumnHeader {
                        display_name: col_def.display_name.clone(),
                        width,
                    }
                })
                .collect()
        });

        let cursor = if self.menu.filtered_count() == 0 {
            0
        } else {
            self.viewport.cursor() - range.start
        };

        ViewState {
            visible_items,
            cursor,
            filter_text: Arc::clone(&self.filter_text),
            total_items: self.menu.total(),
            total_filtered: self.menu.filtered_count(),
            mode: self.mode,
            selection_count: self.selection.count(),
            multi_enabled: self.selection.multi_enabled,
            columns,
            generation: self.generation,
        }
    }

    /// Send the current view state to all subscribers.
    fn broadcast_state(&mut self) {
        let vs = self.build_view_state();
        trace!(
            generation = vs.generation,
            filtered = vs.total_filtered,
            "state broadcast"
        );
        let _ = self.event_tx.send(MenuEvent::StateChanged(vs));
    }

    /// Emit a hook event through the dispatcher, if one is set.
    fn emit_hook(&mut self, event: HookEvent) {
        if let Some(dispatcher) = &mut self.dispatcher {
            debug!(hook_event = ?event.kind(), "hook dispatched");
            dispatcher.dispatch(event);
        }
    }

    /// Check if the cursor moved to a different item and
    /// emit a Hover event if so.
    fn check_cursor_hover(&mut self) {
        if self.menu.filtered_count() == 0 {
            self.previous_cursor = None;
            return;
        }
        let current = self.viewport.cursor();
        let current_orig = self.menu.original_index(current);
        if current_orig != self.previous_cursor {
            self.previous_cursor = current_orig;
            if let Some(value) = self.menu.serialize_filtered(current).cloned()
                && let Some(orig_idx) = current_orig
            {
                trace!(cursor = current, original_index = orig_idx, "hover changed");
                self.emit_hook(HookEvent::Hover {
                    item: value,
                    index: orig_idx,
                });
            }
        }
    }

    /// Apply a single action to the menu state. Pure state
    /// transition: no channels, no async. Testable in isolation.
    pub fn apply_action(&mut self, action: Action) -> ActionOutcome {
        match action {
            Action::UpdateFilter(text) => {
                debug!(filter = %text, "filter updated");
                self.filter_text = Arc::from(text);
                self.run_filter();
                ActionOutcome::Broadcast
            }
            Action::MoveUp(n) => {
                self.viewport.move_up(n);
                ActionOutcome::Broadcast
            }
            Action::MoveDown(n) => {
                self.viewport.move_down(n);
                ActionOutcome::Broadcast
            }
            Action::MoveToTop => {
                self.viewport.move_to_top();
                ActionOutcome::Broadcast
            }
            Action::MoveToBottom => {
                self.viewport.move_to_bottom();
                ActionOutcome::Broadcast
            }
            Action::PageUp(n) => {
                self.viewport.page_up(n);
                ActionOutcome::Broadcast
            }
            Action::PageDown(n) => {
                self.viewport.page_down(n);
                ActionOutcome::Broadcast
            }
            Action::ToggleSelect => {
                if !self.selection.multi_enabled {
                    return ActionOutcome::NoOp;
                }
                if self.menu.filtered_count() == 0 {
                    return ActionOutcome::NoOp;
                }
                let cursor = self.viewport.cursor();
                if let Some(orig_idx) = self.menu.original_index(cursor) {
                    self.selection.toggle(orig_idx);
                }
                ActionOutcome::Broadcast
            }
            Action::SelectRange { start, end } => {
                if !self.selection.multi_enabled {
                    return ActionOutcome::NoOp;
                }
                let min = start.min(end);
                let max = start.max(end);
                let indices: Vec<usize> = (min..=max)
                    .filter_map(|i| self.menu.original_index(i))
                    .collect();
                self.selection.select_range(indices.into_iter());
                ActionOutcome::Broadcast
            }
            Action::ClearSelections => {
                self.selection.clear();
                ActionOutcome::Broadcast
            }
            Action::SelectAll => {
                if !self.selection.multi_enabled {
                    return ActionOutcome::NoOp;
                }
                let indices: Vec<usize> = (0..self.menu.filtered_count())
                    .filter_map(|i| self.menu.original_index(i))
                    .collect();
                self.selection.select_all(indices.into_iter());
                ActionOutcome::Broadcast
            }
            Action::UndoSelection => {
                self.selection.undo();
                ActionOutcome::Broadcast
            }
            Action::RedoSelection => {
                self.selection.redo();
                ActionOutcome::Broadcast
            }
            Action::Confirm => {
                if self.menu.filtered_count() == 0 && self.selection.count() == 0 {
                    return ActionOutcome::NoOp;
                }
                if self.selection.multi_enabled && self.selection.count() > 0 {
                    // Multi-select: return all selected items
                    let indices = if self.selection.selection_order {
                        self.selection.insertion_ordered()
                    } else {
                        self.selection.ordered_items()
                    };
                    let items: Vec<(Value, usize)> = indices
                        .into_iter()
                        .filter_map(|orig_idx| {
                            self.menu
                                .serialize_original(orig_idx)
                                .map(|v| (v.clone(), orig_idx))
                        })
                        .collect();
                    if items.is_empty() {
                        return ActionOutcome::NoOp;
                    }
                    ActionOutcome::Selected { items }
                } else {
                    // Single-select: cursor item as one-element vec
                    if self.menu.filtered_count() == 0 {
                        return ActionOutcome::NoOp;
                    }
                    let cursor = self.viewport.cursor();
                    let index = self.menu.original_index(cursor).unwrap_or(0);
                    match self.menu.serialize_filtered(cursor) {
                        Some(value) => ActionOutcome::Selected {
                            items: vec![(value.clone(), index)],
                        },
                        None => ActionOutcome::NoOp,
                    }
                }
            }
            Action::Quicklist => {
                if self.menu.filtered_count() == 0 {
                    return ActionOutcome::NoOp;
                }
                let items: Vec<(Value, usize)> = self
                    .menu
                    .collect_filtered()
                    .into_iter()
                    .map(|(v, idx)| (v.clone(), idx))
                    .collect();
                ActionOutcome::Quicklist { items }
            }
            Action::Cancel => ActionOutcome::Cancelled,
            Action::Resize { height } => {
                trace!(height, "viewport resized");
                self.viewport.set_height(height as usize);
                ActionOutcome::Broadcast
            }
            Action::HalfPageUp(n) => {
                self.viewport.half_page_up(n);
                ActionOutcome::Broadcast
            }
            Action::HalfPageDown(n) => {
                self.viewport.half_page_down(n);
                ActionOutcome::Broadcast
            }
            Action::SetMode(m) => {
                debug!(mode = ?m, "mode changed");
                if m == Mode::Visual {
                    self.visual_anchor = Some(self.viewport.cursor());
                } else if self.mode == Mode::Visual {
                    self.visual_anchor = None;
                }
                self.mode = m;
                ActionOutcome::Broadcast
            }
            Action::AddItems(values) => {
                debug!(count = values.len(), "items added");
                self.menu.add_raw(values);
                self.run_filter();
                ActionOutcome::Broadcast
            }
            Action::ReplaceItems(values) => {
                debug!(count = values.len(), "items replaced");
                // Smart cursor: try to keep selection on the same original item.
                let cursor = self.viewport.cursor();
                let old_value = self.menu.serialize_filtered(cursor).cloned();
                self.menu.replace_all(values);
                self.run_filter();
                // Try to find the old item in the new set
                if let Some(ref old_val) = old_value {
                    let mut found = false;
                    for i in 0..self.menu.filtered_count() {
                        if self.menu.serialize_filtered(i) == Some(old_val) {
                            self.viewport.set_cursor(i);
                            found = true;
                            break;
                        }
                    }
                    if !found {
                        self.viewport.clamp();
                    }
                } else {
                    self.viewport.clamp();
                }
                ActionOutcome::Broadcast
            }
            Action::RemoveItems(indices) => {
                debug!(count = indices.len(), "items removed");
                self.menu.remove_by_indices(indices);
                self.run_filter();
                self.viewport.clamp();
                ActionOutcome::Broadcast
            }
            Action::ProcessHookResponse(resp) => {
                let action = hook_response_to_action(resp);
                self.apply_action(action)
            }
            Action::CloseMenu => ActionOutcome::Closed,
        }
    }

    /// Set the initial mode before running the event loop.
    /// Used by `--start-mode` CLI flag.
    pub fn set_initial_mode(&mut self, mode: Mode) {
        self.mode = mode;
    }

    /// Run the menu event loop. Consumes actions and
    /// broadcasts events.
    ///
    /// **Ordering guarantee:** Actions are processed
    /// sequentially in the order received. Each action's
    /// state change is fully applied before the next action
    /// begins. A `Confirm` sent right after an
    /// `UpdateFilter` will always select from the filtered
    /// results, never stale pre-filter state.
    ///
    /// This holds regardless of how actions are sent (TUI
    /// keypresses, headless scripts, programmatic sends).
    /// It's enforced by the single `recv()` loop below and
    /// must be preserved by any future refactors.
    pub async fn run(mut self) -> Result<MenuResult, PiklError> {
        self.run_filter();
        self.broadcast_state();

        let total_items = self.menu.total();
        let filtered = self.menu.filtered_count();
        info!(total_items, filtered, "menu opened");

        // Emit Open event
        self.emit_hook(HookEvent::Open);

        while let Some(action) = self.action_rx.recv().await {
            let is_filter_update = matches!(&action, Action::UpdateFilter(_));

            match self.apply_action(action) {
                ActionOutcome::Broadcast => {
                    self.broadcast_state();

                    // Emit Filter event if the filter changed
                    if is_filter_update {
                        let text = self.filter_text.to_string();
                        self.emit_hook(HookEvent::Filter { text });
                    }

                    // Check for cursor movement -> Hover
                    self.check_cursor_hover();
                }
                ActionOutcome::Selected { items } => {
                    let count = items.len();
                    info!(count, "item(s) selected");
                    // Emit Select event for the first item (primary selection)
                    if let Some((value, index)) = items.first() {
                        self.emit_hook(HookEvent::Select {
                            item: value.clone(),
                            index: *index,
                        });
                    }
                    // Emit Close event
                    self.emit_hook(HookEvent::Close);

                    let _ = self.event_tx.send(MenuEvent::Selected(items.clone()));
                    return Ok(MenuResult::Selected { items });
                }
                ActionOutcome::Quicklist { items } => {
                    let values: Vec<Value> = items.iter().map(|(v, _)| v.clone()).collect();
                    let count = values.len();
                    info!(count, "quicklist returned");
                    self.emit_hook(HookEvent::Quicklist {
                        items: values.clone(),
                        count,
                    });
                    self.emit_hook(HookEvent::Close);

                    let _ = self.event_tx.send(MenuEvent::Quicklist(values));
                    return Ok(MenuResult::Quicklist { items });
                }
                ActionOutcome::Cancelled => {
                    info!("menu cancelled");
                    self.emit_hook(HookEvent::Cancel);
                    self.emit_hook(HookEvent::Close);

                    let _ = self.event_tx.send(MenuEvent::Cancelled);
                    return Ok(MenuResult::Cancelled);
                }
                ActionOutcome::Closed => {
                    info!("menu closed by hook");
                    self.emit_hook(HookEvent::Close);

                    let _ = self.event_tx.send(MenuEvent::Cancelled);
                    return Ok(MenuResult::Cancelled);
                }
                ActionOutcome::NoOp => {}
            }
        }

        // Sender dropped
        self.emit_hook(HookEvent::Close);
        Ok(MenuResult::Cancelled)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::event::MenuEvent;
    use crate::item::Item;
    use crate::model::traits::Menu;
    use crate::runtime::json_menu::JsonMenu;

    fn test_menu() -> (MenuRunner<JsonMenu>, mpsc::Sender<Action>) {
        let items = vec![
            Item::from_plain_text("alpha"),
            Item::from_plain_text("beta"),
            Item::from_plain_text("gamma"),
            Item::from_plain_text("delta"),
        ];
        MenuRunner::new(JsonMenu::new(items, "label".to_string()))
    }

    /// Set up a menu runner with filter applied and viewport sized.
    /// Ready for sync apply_action tests.
    fn ready_menu() -> MenuRunner<JsonMenu> {
        let (mut m, _tx) = test_menu();
        m.run_filter();
        m.apply_action(Action::Resize { height: 10 });
        m
    }

    // -- Sync apply_action tests --

    #[test]
    fn apply_move_down_updates_viewport() {
        let mut m = ready_menu();
        let outcome = m.apply_action(Action::MoveDown(1));
        assert!(matches!(outcome, ActionOutcome::Broadcast));
        assert_eq!(m.viewport.cursor(), 1);
    }

    #[test]
    fn apply_move_up_updates_viewport() {
        let mut m = ready_menu();
        m.apply_action(Action::MoveDown(2));
        let outcome = m.apply_action(Action::MoveUp(1));
        assert!(matches!(outcome, ActionOutcome::Broadcast));
        assert_eq!(m.viewport.cursor(), 1);
    }

    #[test]
    fn apply_filter_changes_results() {
        let mut m = ready_menu();
        let outcome = m.apply_action(Action::UpdateFilter("al".to_string()));
        assert!(matches!(outcome, ActionOutcome::Broadcast));
        assert_eq!(&*m.filter_text, "al");
        // alpha matches "al"
        assert!(m.menu.filtered_count() >= 1);
    }

    #[test]
    fn apply_confirm_returns_selected() {
        let mut m = ready_menu();
        m.apply_action(Action::MoveDown(1));
        let outcome = m.apply_action(Action::Confirm);
        assert!(
            matches!(&outcome, ActionOutcome::Selected { items } if items[0].0.as_str() == Some("beta"))
        );
    }

    #[test]
    fn apply_confirm_on_empty_is_noop() {
        let mut m = ready_menu();
        m.apply_action(Action::UpdateFilter("zzzzz".to_string()));
        assert_eq!(m.menu.filtered_count(), 0);
        let outcome = m.apply_action(Action::Confirm);
        assert!(matches!(outcome, ActionOutcome::NoOp));
    }

    #[test]
    fn apply_cancel_returns_cancelled() {
        let mut m = ready_menu();
        let outcome = m.apply_action(Action::Cancel);
        assert!(matches!(outcome, ActionOutcome::Cancelled));
    }

    #[test]
    fn apply_resize_updates_viewport() {
        let mut m = ready_menu();
        let outcome = m.apply_action(Action::Resize { height: 3 });
        assert!(matches!(outcome, ActionOutcome::Broadcast));
        assert_eq!(m.viewport.visible_range(), 0..3);
    }

    #[test]
    fn apply_add_items_runs_filter() {
        let mut m = ready_menu();
        assert_eq!(m.menu.total(), 4);
        let outcome = m.apply_action(Action::AddItems(vec![serde_json::Value::String(
            "epsilon".to_string(),
        )]));
        assert!(matches!(outcome, ActionOutcome::Broadcast));
        assert_eq!(m.menu.total(), 5);
        assert_eq!(m.menu.filtered_count(), 5);
    }

    #[test]
    fn apply_move_to_top_and_bottom() {
        let mut m = ready_menu();
        m.apply_action(Action::MoveToBottom);
        assert_eq!(m.viewport.cursor(), 3);
        m.apply_action(Action::MoveToTop);
        assert_eq!(m.viewport.cursor(), 0);
    }

    #[test]
    fn apply_page_movement() {
        let (mut m, _tx) = test_menu();
        m.run_filter();
        m.apply_action(Action::Resize { height: 2 });
        m.apply_action(Action::PageDown(1));
        assert_eq!(m.viewport.cursor(), 2);
        m.apply_action(Action::PageUp(1));
        assert_eq!(m.viewport.cursor(), 0);
    }

    #[tokio::test]
    async fn initial_state_broadcast() {
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();

        let handle = tokio::spawn(async move { menu.run().await });

        // Should receive initial state
        if let Ok(MenuEvent::StateChanged(vs)) = rx.recv().await {
            assert_eq!(vs.total_items, 4);
            assert_eq!(vs.total_filtered, 4);
            assert_eq!(vs.cursor, 0);
            assert!(vs.filter_text.is_empty());
        }

        // Cancel to exit
        let _ = tx.send(Action::Cancel).await;
        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        assert!(matches!(result, Ok(MenuResult::Cancelled)));
    }

    #[tokio::test]
    async fn filter_updates() {
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();

        let handle = tokio::spawn(async move { menu.run().await });

        // Skip initial state
        let _ = rx.recv().await;

        // Filter to "al"
        let _ = tx.send(Action::UpdateFilter("al".to_string())).await;
        if let Ok(MenuEvent::StateChanged(vs)) = rx.recv().await {
            assert_eq!(vs.total_items, 4);
            // alpha should match "al"
            assert!(vs.total_filtered >= 1);
            assert_eq!(&*vs.filter_text, "al");
        }

        let _ = tx.send(Action::Cancel).await;
        let _ = handle.await;
    }

    #[tokio::test]
    async fn confirm_selection() {
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();

        let handle = tokio::spawn(async move { menu.run().await });

        // Skip initial state
        let _ = rx.recv().await;

        // Need to send resize first so viewport has height
        let _ = tx.send(Action::Resize { height: 10 }).await;
        let _ = rx.recv().await;

        // Move down and confirm
        let _ = tx.send(Action::MoveDown(1)).await;
        let _ = rx.recv().await;
        let _ = tx.send(Action::Confirm).await;

        // Should get Selected event
        if let Ok(MenuEvent::Selected(items)) = rx.recv().await {
            assert_eq!(items[0].0.as_str(), Some("beta"));
        }

        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        assert!(matches!(result, Ok(MenuResult::Selected { .. })));
    }

    #[tokio::test]
    async fn confirm_on_empty_is_noop() {
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();

        let handle = tokio::spawn(async move { menu.run().await });

        let _ = rx.recv().await; // initial

        // Filter to something that matches nothing
        let _ = tx.send(Action::UpdateFilter("zzzzz".to_string())).await;
        if let Ok(MenuEvent::StateChanged(vs)) = rx.recv().await {
            assert_eq!(vs.total_filtered, 0);
        }

        // Confirm should be no-op
        let _ = tx.send(Action::Confirm).await;

        // Cancel to exit (should still work)
        let _ = tx.send(Action::Cancel).await;
        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        assert!(matches!(result, Ok(MenuResult::Cancelled)));
    }

    #[tokio::test]
    async fn sender_drop_cancels() {
        let (menu, tx) = test_menu();
        let _rx = menu.subscribe();

        let handle = tokio::spawn(async move { menu.run().await });

        // Drop the only sender.
        drop(tx);

        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        assert!(matches!(result, Ok(MenuResult::Cancelled)));
    }

    // -- End-to-end output correctness --

    #[tokio::test]
    async fn confirm_first_item_value() {
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();

        let handle = tokio::spawn(async move { menu.run().await });

        let _ = rx.recv().await; // initial state
        let _ = tx.send(Action::Resize { height: 10 }).await;
        let _ = rx.recv().await;

        // Confirm at cursor 0, should get "alpha"
        let _ = tx.send(Action::Confirm).await;

        let event = rx.recv().await;
        assert!(
            matches!(&event, Ok(MenuEvent::Selected(items)) if items[0].0.as_str() == Some("alpha"))
        );

        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        assert!(
            matches!(result, Ok(MenuResult::Selected { ref items, .. }) if items[0].0.as_str() == Some("alpha"))
        );
    }

    #[tokio::test]
    async fn confirm_third_item_value() {
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();

        let handle = tokio::spawn(async move { menu.run().await });

        let _ = rx.recv().await; // initial
        let _ = tx.send(Action::Resize { height: 10 }).await;
        let _ = rx.recv().await;

        // Move down twice -> cursor at index 2 -> "gamma"
        let _ = tx.send(Action::MoveDown(1)).await;
        let _ = rx.recv().await;
        let _ = tx.send(Action::MoveDown(1)).await;
        let _ = rx.recv().await;
        let _ = tx.send(Action::Confirm).await;

        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        assert!(
            matches!(result, Ok(MenuResult::Selected { ref items, .. }) if items[0].0.as_str() == Some("gamma"))
        );
    }

    #[tokio::test]
    async fn filter_then_confirm_correct_item() {
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();

        let handle = tokio::spawn(async move { menu.run().await });

        let _ = rx.recv().await; // initial
        let _ = tx.send(Action::Resize { height: 10 }).await;
        let _ = rx.recv().await;

        // Filter to "del", should match "delta"
        let _ = tx.send(Action::UpdateFilter("del".to_string())).await;
        if let Ok(MenuEvent::StateChanged(vs)) = rx.recv().await {
            assert!(vs.total_filtered >= 1);
            assert_eq!(vs.visible_items[0].label, "delta");
        }

        // Confirm, should select "delta"
        let _ = tx.send(Action::Confirm).await;

        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        assert!(
            matches!(result, Ok(MenuResult::Selected { ref items, .. }) if items[0].0.as_str() == Some("delta"))
        );
    }

    #[tokio::test]
    async fn add_items_then_confirm_new_item() {
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();

        let handle = tokio::spawn(async move { menu.run().await });

        let _ = rx.recv().await; // initial
        let _ = tx.send(Action::Resize { height: 10 }).await;
        let _ = rx.recv().await;

        // Add a new item
        let _ = tx
            .send(Action::AddItems(vec![serde_json::Value::String(
                "epsilon".to_string(),
            )]))
            .await;
        if let Ok(MenuEvent::StateChanged(vs)) = rx.recv().await {
            assert_eq!(vs.total_items, 5);
            assert_eq!(vs.total_filtered, 5);
        }

        // Filter to "eps", only epsilon should match
        let _ = tx.send(Action::UpdateFilter("eps".to_string())).await;
        if let Ok(MenuEvent::StateChanged(vs)) = rx.recv().await {
            assert!(vs.total_filtered >= 1);
            assert_eq!(vs.visible_items[0].label, "epsilon");
        }

        let _ = tx.send(Action::Confirm).await;

        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        assert!(
            matches!(result, Ok(MenuResult::Selected { ref items, .. }) if items[0].0.as_str() == Some("epsilon"))
        );
    }

    #[tokio::test]
    async fn cancel_returns_no_item() {
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();

        let handle = tokio::spawn(async move { menu.run().await });

        let _ = rx.recv().await; // initial

        let _ = tx.send(Action::Cancel).await;

        // Should get Cancelled event
        assert!(matches!(rx.recv().await, Ok(MenuEvent::Cancelled)));

        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        assert!(matches!(result, Ok(MenuResult::Cancelled)));
    }

    // -- Ordering invariant tests --
    // These tests verify the sequential processing guarantee documented on
    // MenuRunner::run(). Actions sent back-to-back without waiting for
    // intermediate events must still be processed in order, each fully
    // applied before the next begins.

    #[tokio::test]
    async fn actions_process_in_order_filter_then_confirm() {
        // Send filter + confirm back-to-back with no recv between them.
        // Confirm must act on the filtered results, not the pre-filter state.
        let items = vec![
            Item::from_plain_text("alpha"),
            Item::from_plain_text("beta"),
            Item::from_plain_text("banana"),
        ];
        let (menu, tx) = MenuRunner::new(JsonMenu::new(items, "label".to_string()));
        let mut rx = menu.subscribe();
        let handle = tokio::spawn(async move { menu.run().await });

        let _ = rx.recv().await; // initial
        let _ = tx.send(Action::Resize { height: 50 }).await;
        let _ = rx.recv().await;

        // Back-to-back, no waiting between these
        let _ = tx.send(Action::UpdateFilter("ban".to_string())).await;
        let _ = tx.send(Action::Confirm).await;

        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        // Must get "banana". Filter was applied before confirm ran.
        assert!(matches!(
            result,
            Ok(MenuResult::Selected { ref items, .. }) if items[0].0.as_str() == Some("banana")
        ));
    }

    #[tokio::test]
    async fn actions_process_in_order_move_then_confirm() {
        // Send multiple moves + confirm back-to-back.
        // Confirm must reflect the final cursor position.
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();
        let handle = tokio::spawn(async move { menu.run().await });

        let _ = rx.recv().await; // initial
        let _ = tx.send(Action::Resize { height: 50 }).await;
        let _ = rx.recv().await;

        // Three moves down back-to-back, then confirm
        let _ = tx.send(Action::MoveDown(1)).await;
        let _ = tx.send(Action::MoveDown(1)).await;
        let _ = tx.send(Action::MoveDown(1)).await;
        let _ = tx.send(Action::Confirm).await;

        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        // Cursor at index 3 -> "delta"
        assert!(matches!(
            result,
            Ok(MenuResult::Selected { ref items, .. }) if items[0].0.as_str() == Some("delta")
        ));
    }

    // -- New action variant tests --

    #[test]
    fn apply_half_page_down() {
        let (mut m, _tx) = test_menu();
        m.run_filter();
        m.apply_action(Action::Resize { height: 4 });
        let outcome = m.apply_action(Action::HalfPageDown(1));
        assert!(matches!(outcome, ActionOutcome::Broadcast));
        assert_eq!(m.viewport.cursor(), 2); // 4/2 = 2
    }

    #[test]
    fn apply_half_page_up() {
        let (mut m, _tx) = test_menu();
        m.run_filter();
        m.apply_action(Action::Resize { height: 4 });
        m.apply_action(Action::HalfPageDown(1));
        let outcome = m.apply_action(Action::HalfPageUp(1));
        assert!(matches!(outcome, ActionOutcome::Broadcast));
        assert_eq!(m.viewport.cursor(), 0);
    }

    #[test]
    fn apply_set_mode_normal() {
        let mut m = ready_menu();
        let outcome = m.apply_action(Action::SetMode(Mode::Normal));
        assert!(matches!(outcome, ActionOutcome::Broadcast));
        assert_eq!(m.build_view_state().mode, Mode::Normal);
    }

    #[test]
    fn apply_set_mode_insert() {
        let mut m = ready_menu();
        m.apply_action(Action::SetMode(Mode::Normal));
        let outcome = m.apply_action(Action::SetMode(Mode::Insert));
        assert!(matches!(outcome, ActionOutcome::Broadcast));
        assert_eq!(m.build_view_state().mode, Mode::Insert);
    }

    #[test]
    fn apply_set_mode_preserves_filter() {
        let mut m = ready_menu();
        m.apply_action(Action::UpdateFilter("al".to_string()));
        let count_before = m.menu.filtered_count();
        let filter_before = m.filter_text.clone();
        m.apply_action(Action::SetMode(Mode::Normal));
        assert_eq!(&*m.filter_text, &*filter_before);
        assert_eq!(m.menu.filtered_count(), count_before);
    }

    #[test]
    fn set_initial_mode_works() {
        let (mut m, _tx) = test_menu();
        m.set_initial_mode(Mode::Normal);
        m.run_filter();
        assert_eq!(m.build_view_state().mode, Mode::Normal);
    }

    #[test]
    fn view_state_mode_after_switch() {
        let mut m = ready_menu();
        m.apply_action(Action::SetMode(Mode::Normal));
        let vs = m.build_view_state();
        assert_eq!(vs.mode, Mode::Normal);
    }

    #[tokio::test]
    async fn actions_process_in_order_add_items_then_filter_then_confirm() {
        // AddItems + filter + confirm, all back-to-back.
        // The filter must see the newly added items.
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();
        let handle = tokio::spawn(async move { menu.run().await });

        let _ = rx.recv().await; // initial
        let _ = tx.send(Action::Resize { height: 50 }).await;
        let _ = rx.recv().await;

        // All back-to-back
        let _ = tx
            .send(Action::AddItems(vec![serde_json::Value::String(
                "zephyr".to_string(),
            )]))
            .await;
        let _ = tx.send(Action::UpdateFilter("zep".to_string())).await;
        let _ = tx.send(Action::Confirm).await;

        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        // Must find "zephyr". It was added before the filter ran.
        assert!(matches!(
            result,
            Ok(MenuResult::Selected { ref items, .. }) if items[0].0.as_str() == Some("zephyr")
        ));
    }

    // -- Replace/Remove/Close action tests --

    #[test]
    fn apply_replace_items() {
        let mut m = ready_menu();
        assert_eq!(m.menu.total(), 4);
        let outcome = m.apply_action(Action::ReplaceItems(vec![
            serde_json::Value::String("x".to_string()),
            serde_json::Value::String("y".to_string()),
        ]));
        assert!(matches!(outcome, ActionOutcome::Broadcast));
        assert_eq!(m.menu.total(), 2);
        assert_eq!(m.menu.filtered_count(), 2);
    }

    #[test]
    fn apply_replace_items_preserves_cursor() {
        let mut m = ready_menu();
        // Move to "beta" (index 1)
        m.apply_action(Action::MoveDown(1));
        // Replace items, keeping "beta" in the new set
        m.apply_action(Action::ReplaceItems(vec![
            serde_json::Value::String("alpha".to_string()),
            serde_json::Value::String("beta".to_string()),
            serde_json::Value::String("zeta".to_string()),
        ]));
        // Cursor should still be on "beta"
        let vs = m.build_view_state();
        assert_eq!(vs.visible_items[vs.cursor].label, "beta");
    }

    #[test]
    fn apply_remove_items() {
        let mut m = ready_menu();
        assert_eq!(m.menu.total(), 4);
        let outcome = m.apply_action(Action::RemoveItems(vec![1, 3]));
        assert!(matches!(outcome, ActionOutcome::Broadcast));
        assert_eq!(m.menu.total(), 2);
        // alpha and gamma should remain
        assert_eq!(m.menu.filtered_label(0), Some("alpha"));
        assert_eq!(m.menu.filtered_label(1), Some("gamma"));
    }

    #[test]
    fn apply_close_menu() {
        let mut m = ready_menu();
        let outcome = m.apply_action(Action::CloseMenu);
        assert!(matches!(outcome, ActionOutcome::Closed));
    }

    #[test]
    fn apply_hook_response_close() {
        use crate::hook::HookResponse;
        let mut m = ready_menu();
        let outcome = m.apply_action(Action::ProcessHookResponse(HookResponse::Close));
        assert!(matches!(outcome, ActionOutcome::Closed));
    }

    #[test]
    fn apply_hook_response_add_items() {
        use crate::hook::HookResponse;
        let mut m = ready_menu();
        let outcome = m.apply_action(Action::ProcessHookResponse(HookResponse::AddItems {
            items: vec![serde_json::json!("new")],
        }));
        assert!(matches!(outcome, ActionOutcome::Broadcast));
        assert_eq!(m.menu.total(), 5);
    }

    #[test]
    fn confirm_returns_original_index() {
        let mut m = ready_menu();
        // Filter to narrow results, then confirm
        m.apply_action(Action::UpdateFilter("del".to_string()));
        assert!(m.menu.filtered_count() >= 1);
        let outcome = m.apply_action(Action::Confirm);
        // "delta" is at original index 3
        assert!(matches!(&outcome, ActionOutcome::Selected { items } if items[0].1 == 3));
    }

    // -- Quicklist tests --

    #[test]
    fn apply_quicklist_returns_all_filtered() {
        let mut m = ready_menu();
        let outcome = m.apply_action(Action::Quicklist);
        match outcome {
            ActionOutcome::Quicklist { items } => {
                assert_eq!(items.len(), 4);
                let labels: Vec<&str> = items.iter().filter_map(|(v, _)| v.as_str()).collect();
                assert_eq!(labels, vec!["alpha", "beta", "gamma", "delta"]);
            }
            other => panic!("expected Quicklist, got {other:?}"),
        }
    }

    #[test]
    fn apply_quicklist_respects_filter() {
        let mut m = ready_menu();
        m.apply_action(Action::UpdateFilter("a".to_string()));
        let outcome = m.apply_action(Action::Quicklist);
        match outcome {
            ActionOutcome::Quicklist { items } => {
                // "alpha", "gamma", "delta" all contain 'a'
                assert!(items.len() >= 2);
                for (v, _) in &items {
                    let label = v.as_str().unwrap_or("");
                    assert!(
                        label.contains('a'),
                        "filtered item should contain 'a': {label}"
                    );
                }
            }
            other => panic!("expected Quicklist, got {other:?}"),
        }
    }

    #[test]
    fn apply_quicklist_on_empty_is_noop() {
        let mut m = ready_menu();
        m.apply_action(Action::UpdateFilter("zzzzz".to_string()));
        assert_eq!(m.menu.filtered_count(), 0);
        let outcome = m.apply_action(Action::Quicklist);
        assert!(matches!(outcome, ActionOutcome::NoOp));
    }

    #[test]
    fn apply_quicklist_preserves_original_indices() {
        let mut m = ready_menu();
        // Filter to "del" -> only "delta" at original index 3
        m.apply_action(Action::UpdateFilter("del".to_string()));
        let outcome = m.apply_action(Action::Quicklist);
        match outcome {
            ActionOutcome::Quicklist { items } => {
                assert_eq!(items.len(), 1);
                assert_eq!(items[0].0.as_str(), Some("delta"));
                assert_eq!(items[0].1, 3);
            }
            other => panic!("expected Quicklist, got {other:?}"),
        }
    }

    #[tokio::test]
    async fn quicklist_event_broadcast() {
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();

        let handle = tokio::spawn(async move { menu.run().await });

        // Skip initial state
        let _ = rx.recv().await;
        let _ = tx.send(Action::Resize { height: 10 }).await;
        let _ = rx.recv().await;

        let _ = tx.send(Action::Quicklist).await;

        if let Ok(MenuEvent::Quicklist(values)) = rx.recv().await {
            assert_eq!(values.len(), 4);
        } else {
            panic!("expected Quicklist event");
        }

        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        assert!(matches!(result, Ok(MenuResult::Quicklist { .. })));
    }

    #[tokio::test]
    async fn quicklist_after_filter() {
        let (menu, tx) = test_menu();
        let mut rx = menu.subscribe();

        let handle = tokio::spawn(async move { menu.run().await });

        let _ = rx.recv().await; // initial
        let _ = tx.send(Action::Resize { height: 10 }).await;
        let _ = rx.recv().await;

        // Filter then quicklist back-to-back
        let _ = tx.send(Action::UpdateFilter("al".to_string())).await;
        let _ = tx.send(Action::Quicklist).await;

        let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
        match result {
            Ok(MenuResult::Quicklist { items }) => {
                // "alpha" matches "al"
                assert!(!items.is_empty());
                for (v, _) in &items {
                    let label = v.as_str().unwrap_or("");
                    assert!(
                        label.contains("al"),
                        "quicklist item should match filter: {label}"
                    );
                }
            }
            other => panic!("expected Quicklist, got {other:?}"),
        }
    }

    // -- Hook event tests --

    #[tokio::test]
    async fn hook_events_fire_on_lifecycle() {
        use crate::hook::{HookEvent, HookEventKind, HookHandler};
        use std::sync::Mutex;

        struct Recorder(Mutex<Vec<HookEventKind>>);
        impl HookHandler for Recorder {
            fn handle(&self, event: HookEvent) -> Result<(), PiklError> {
                if let Ok(mut v) = self.0.lock() {
                    v.push(event.kind());
                }
                Ok(())
            }
        }

        let recorder = Arc::new(Recorder(Mutex::new(Vec::new())));
        let (mut m, action_tx) = test_menu();
        m.set_hook_handler(Arc::clone(&recorder) as Arc<dyn HookHandler>, action_tx);
        m.run_filter();
        m.apply_action(Action::Resize { height: 10 });

        // Simulate lifecycle: the Open event is emitted in run(),
        // but we can test Filter/Hover/Cancel manually
        m.emit_hook(HookEvent::Open);
        m.apply_action(Action::UpdateFilter("al".to_string()));
        m.emit_hook(HookEvent::Filter {
            text: "al".to_string(),
        });
        m.apply_action(Action::MoveDown(1));
        m.check_cursor_hover();

        // Give spawned tasks a chance to complete
        tokio::task::yield_now().await;
        tokio::time::sleep(std::time::Duration::from_millis(10)).await;

        let events = recorder.0.lock().map(|v| v.clone()).unwrap_or_default();
        assert!(events.contains(&HookEventKind::Open));
        assert!(events.contains(&HookEventKind::Filter));
    }

    // -- SelectionState unit tests --

    #[test]
    fn selection_toggle_adds_and_removes() {
        let mut s = SelectionState::new();
        s.multi_enabled = true;
        s.toggle(3);
        assert!(s.is_selected(3));
        assert_eq!(s.count(), 1);
        s.toggle(3);
        assert!(!s.is_selected(3));
        assert_eq!(s.count(), 0);
    }

    #[test]
    fn selection_undo_redo() {
        let mut s = SelectionState::new();
        s.multi_enabled = true;
        s.toggle(1);
        s.toggle(2);
        assert_eq!(s.count(), 2);
        s.undo();
        assert_eq!(s.count(), 1);
        assert!(s.is_selected(1));
        assert!(!s.is_selected(2));
        s.redo();
        assert_eq!(s.count(), 2);
        assert!(s.is_selected(2));
    }

    #[test]
    fn selection_undo_on_empty_is_noop() {
        let mut s = SelectionState::new();
        s.undo();
        assert_eq!(s.count(), 0);
    }

    #[test]
    fn selection_redo_on_empty_is_noop() {
        let mut s = SelectionState::new();
        s.redo();
        assert_eq!(s.count(), 0);
    }

    #[test]
    fn selection_clear_then_undo_restores() {
        let mut s = SelectionState::new();
        s.multi_enabled = true;
        s.toggle(0);
        s.toggle(2);
        assert_eq!(s.count(), 2);
        s.clear();
        assert_eq!(s.count(), 0);
        s.undo();
        assert_eq!(s.count(), 2);
        assert!(s.is_selected(0));
        assert!(s.is_selected(2));
    }

    #[test]
    fn selection_select_range() {
        let mut s = SelectionState::new();
        s.multi_enabled = true;
        s.select_range([1, 2, 3].into_iter());
        assert_eq!(s.count(), 3);
        assert!(s.is_selected(1));
        assert!(s.is_selected(2));
        assert!(s.is_selected(3));
    }

    #[test]
    fn selection_select_all() {
        let mut s = SelectionState::new();
        s.multi_enabled = true;
        s.select_all([0, 1, 2, 3].into_iter());
        assert_eq!(s.count(), 4);
    }

    #[test]
    fn selection_ordered_items_sorted() {
        let mut s = SelectionState::new();
        s.multi_enabled = true;
        s.toggle(3);
        s.toggle(1);
        s.toggle(0);
        assert_eq!(s.ordered_items(), vec![0, 1, 3]);
    }

    #[test]
    fn selection_insertion_ordered() {
        let mut s = SelectionState::new();
        s.multi_enabled = true;
        s.toggle(3);
        s.toggle(1);
        s.toggle(0);
        assert_eq!(s.insertion_ordered(), vec![3, 1, 0]);
    }

    #[test]
    fn selection_new_action_clears_redo() {
        let mut s = SelectionState::new();
        s.multi_enabled = true;
        s.toggle(1);
        s.toggle(2);
        s.undo(); // redo stack has the {1,2} state
        s.toggle(3); // new action, should clear redo
        s.redo(); // should be noop
        assert_eq!(s.count(), 2);
        assert!(s.is_selected(1));
        assert!(s.is_selected(3));
    }

    // -- Multi-select integration tests (apply_action) --

    fn ready_multi_menu() -> MenuRunner<JsonMenu> {
        let (mut m, _tx) = test_menu();
        m.set_multi(true);
        m.run_filter();
        m.apply_action(Action::Resize { height: 10 });
        m
    }

    #[test]
    fn toggle_then_confirm_returns_selected() {
        let mut m = ready_multi_menu();
        m.apply_action(Action::MoveDown(1)); // cursor on "beta"
        m.apply_action(Action::ToggleSelect);
        let outcome = m.apply_action(Action::Confirm);
        match outcome {
            ActionOutcome::Selected { items } => {
                assert_eq!(items.len(), 1);
                assert_eq!(items[0].0.as_str(), Some("beta"));
                assert_eq!(items[0].1, 1);
            }
            other => panic!("expected Selected, got {other:?}"),
        }
    }

    #[test]
    fn toggle_two_items_confirm_returns_both() {
        let mut m = ready_multi_menu();
        m.apply_action(Action::ToggleSelect); // select "alpha" (0)
        m.apply_action(Action::MoveDown(2)); // cursor on "gamma" (2)
        m.apply_action(Action::ToggleSelect);
        let outcome = m.apply_action(Action::Confirm);
        match outcome {
            ActionOutcome::Selected { items } => {
                assert_eq!(items.len(), 2);
                // Default order = input order
                assert_eq!(items[0].0.as_str(), Some("alpha"));
                assert_eq!(items[1].0.as_str(), Some("gamma"));
            }
            other => panic!("expected Selected, got {other:?}"),
        }
    }

    #[test]
    fn toggle_then_untoggle_falls_back_to_cursor() {
        let mut m = ready_multi_menu();
        m.apply_action(Action::MoveDown(1)); // cursor on "beta"
        m.apply_action(Action::ToggleSelect);
        m.apply_action(Action::ToggleSelect); // untoggle
        let outcome = m.apply_action(Action::Confirm);
        match outcome {
            ActionOutcome::Selected { items } => {
                // No selections, fallback to cursor
                assert_eq!(items.len(), 1);
                assert_eq!(items[0].0.as_str(), Some("beta"));
            }
            other => panic!("expected Selected, got {other:?}"),
        }
    }

    #[test]
    fn multi_no_selections_returns_cursor() {
        let mut m = ready_multi_menu();
        m.apply_action(Action::MoveDown(2)); // cursor on "gamma"
        let outcome = m.apply_action(Action::Confirm);
        match outcome {
            ActionOutcome::Selected { items } => {
                assert_eq!(items.len(), 1);
                assert_eq!(items[0].0.as_str(), Some("gamma"));
            }
            other => panic!("expected Selected, got {other:?}"),
        }
    }

    #[test]
    fn select_all_then_confirm() {
        let mut m = ready_multi_menu();
        m.apply_action(Action::SelectAll);
        let outcome = m.apply_action(Action::Confirm);
        match outcome {
            ActionOutcome::Selected { items } => {
                assert_eq!(items.len(), 4);
                let labels: Vec<&str> = items.iter().filter_map(|(v, _)| v.as_str()).collect();
                assert_eq!(labels, vec!["alpha", "beta", "gamma", "delta"]);
            }
            other => panic!("expected Selected, got {other:?}"),
        }
    }

    #[test]
    fn clear_selections_after_select() {
        let mut m = ready_multi_menu();
        m.apply_action(Action::ToggleSelect); // select alpha
        m.apply_action(Action::ClearSelections);
        assert_eq!(m.selection.count(), 0);
        let outcome = m.apply_action(Action::Confirm);
        match outcome {
            ActionOutcome::Selected { items } => {
                assert_eq!(items.len(), 1);
                assert_eq!(items[0].0.as_str(), Some("alpha")); // cursor item
            }
            other => panic!("expected Selected, got {other:?}"),
        }
    }

    #[test]
    fn undo_redo_through_apply_action() {
        let mut m = ready_multi_menu();
        m.apply_action(Action::ToggleSelect); // select alpha
        m.apply_action(Action::MoveDown(1));
        m.apply_action(Action::ToggleSelect); // select beta
        assert_eq!(m.selection.count(), 2);
        m.apply_action(Action::UndoSelection);
        assert_eq!(m.selection.count(), 1);
        assert!(m.selection.is_selected(0)); // alpha
        assert!(!m.selection.is_selected(1)); // beta undone
        m.apply_action(Action::RedoSelection);
        assert_eq!(m.selection.count(), 2);
    }

    #[test]
    fn selections_survive_filter_change() {
        let mut m = ready_multi_menu();
        m.apply_action(Action::ToggleSelect); // select alpha (orig idx 0)
        m.apply_action(Action::MoveDown(1));
        m.apply_action(Action::ToggleSelect); // select beta (orig idx 1)
        // Change filter
        m.apply_action(Action::UpdateFilter("del".to_string()));
        // Selections should survive
        assert_eq!(m.selection.count(), 2);
        assert!(m.selection.is_selected(0));
        assert!(m.selection.is_selected(1));
        // Confirm should return the selected items (alpha, beta) even
        // though they're not in the filtered set
        let outcome = m.apply_action(Action::Confirm);
        match outcome {
            ActionOutcome::Selected { items } => {
                assert_eq!(items.len(), 2);
                assert_eq!(items[0].0.as_str(), Some("alpha"));
                assert_eq!(items[1].0.as_str(), Some("beta"));
            }
            other => panic!("expected Selected, got {other:?}"),
        }
    }

    #[test]
    fn multi_disabled_toggle_is_noop() {
        let mut m = ready_menu(); // not multi
        let outcome = m.apply_action(Action::ToggleSelect);
        assert!(matches!(outcome, ActionOutcome::NoOp));
    }

    #[test]
    fn select_range_selects_all_in_range() {
        let mut m = ready_multi_menu();
        m.apply_action(Action::SelectRange { start: 1, end: 3 });
        assert_eq!(m.selection.count(), 3);
        assert!(!m.selection.is_selected(0));
        assert!(m.selection.is_selected(1));
        assert!(m.selection.is_selected(2));
        assert!(m.selection.is_selected(3));
    }

    #[test]
    fn visual_anchor_set_on_visual_mode() {
        let mut m = ready_multi_menu();
        m.apply_action(Action::MoveDown(2)); // cursor at 2
        m.apply_action(Action::SetMode(Mode::Visual));
        assert_eq!(m.visual_anchor, Some(2));
        m.apply_action(Action::SetMode(Mode::Normal));
        assert_eq!(m.visual_anchor, None);
    }

    #[test]
    fn view_state_shows_selection() {
        let mut m = ready_multi_menu();
        m.apply_action(Action::ToggleSelect); // select alpha
        let vs = m.build_view_state();
        assert!(vs.multi_enabled);
        assert_eq!(vs.selection_count, 1);
        assert!(vs.visible_items[0].selected);
        assert!(!vs.visible_items[1].selected);
    }

    // -- Column / table mode tests --

    use crate::model::column::ColumnConfig;

    fn table_menu() -> MenuRunner<JsonMenu> {
        let items = vec![
            Item::new(
                serde_json::json!({"label": "alice", "meta": {"age": "30", "city": "toronto"}}),
                "label",
            ),
            Item::new(
                serde_json::json!({"label": "bob", "meta": {"age": "25", "city": "vancouver"}}),
                "label",
            ),
            Item::new(
                serde_json::json!({"label": "charlie", "meta": {"age": "35", "city": "montreal"}}),
                "label",
            ),
        ];
        let mut json_menu = JsonMenu::new(items, "label".to_string());
        json_menu.set_column_config(ColumnConfig::parse("label,meta.age:Age,meta.city:City"));
        let (runner, _tx) = MenuRunner::new(json_menu);
        runner
    }

    fn ready_table_menu() -> MenuRunner<JsonMenu> {
        let mut m = table_menu();
        m.run_filter();
        m.apply_action(Action::Resize { height: 10 });
        m
    }

    #[test]
    fn view_state_has_columns_when_config_set() {
        let mut m = ready_table_menu();
        let vs = m.build_view_state();
        assert!(vs.columns.is_some(), "columns should be Some");
        let cols = vs.columns.as_ref().unwrap();
        assert_eq!(cols.len(), 3);
        assert_eq!(cols[0].display_name, "label");
        assert_eq!(cols[1].display_name, "Age");
        assert_eq!(cols[2].display_name, "City");
    }

    #[test]
    fn view_state_column_widths_computed() {
        let mut m = ready_table_menu();
        let vs = m.build_view_state();
        let cols = vs.columns.as_ref().unwrap();
        // "label" header is 5 chars, "charlie" is 7 chars: width should be 7
        assert_eq!(cols[0].width, 7);
        // "Age" header is 3 chars, max cell "35" is 2 chars: width should be 3
        assert_eq!(cols[1].width, 3);
        // "City" header is 4 chars, "vancouver" is 9 chars: width should be 9
        assert_eq!(cols[2].width, 9);
    }

    #[test]
    fn view_state_items_have_column_values() {
        let mut m = ready_table_menu();
        let vs = m.build_view_state();
        let item = &vs.visible_items[0];
        assert!(item.column_values.is_some());
        let vals = item.column_values.as_ref().unwrap();
        assert_eq!(vals, &["alice", "30", "toronto"]);
    }

    #[test]
    fn view_state_no_columns_without_config() {
        let mut m = ready_menu();
        let vs = m.build_view_state();
        assert!(vs.columns.is_none());
        assert!(vs.visible_items[0].column_values.is_none());
    }

    #[test]
    fn table_mode_filter_still_works() {
        let mut m = ready_table_menu();
        m.apply_action(Action::UpdateFilter("bob".to_string()));
        let vs = m.build_view_state();
        assert_eq!(vs.total_filtered, 1);
        assert_eq!(vs.visible_items[0].label, "bob");
        // Column values should still be present
        let vals = vs.visible_items[0].column_values.as_ref().unwrap();
        assert_eq!(vals, &["bob", "25", "vancouver"]);
    }

    #[test]
    fn table_mode_column_widths_change_with_filter() {
        let mut m = ready_table_menu();
        m.apply_action(Action::UpdateFilter("alice".to_string()));
        let vs = m.build_view_state();
        let cols = vs.columns.as_ref().unwrap();
        // Only "alice" visible now, so label width = max(5, 5) = 5
        assert_eq!(cols[0].width, 5);
        // City "toronto" (7) vs header "City" (4): width = 7
        assert_eq!(cols[2].width, 7);
    }
}