vizia_core/views/

list.rs

use std::{
    collections::BTreeSet,
    ops::Deref,
    rc::Rc,
    time::{Duration, Instant},
};
use vizia_reactive::{Scope, SignalGet, SignalWith, UpdaterEffect};

use crate::prelude::*;
use crate::{binding::BindingHandler, context::SIGNAL_REBUILDS, context::SignalRebuild};

/// Represents how items can be selected in a list.
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub enum Selectable {
    #[default]
    /// Items in the list cannot be selected.
    None,
    /// A single item in the list can be selected.
    Single,
    /// Multiple items in the list can be selected simultaneously.
    Multi,
}

impl_res_simple!(Selectable);

/// Events used by the [List] view
pub enum ListEvent {
    /// Selects a list item with the given index.
    Select(usize),
    /// Selects the focused list item.
    SelectFocused,
    /// Moves focus to a specific item index without changing selection.
    Focus(usize),
    ///  Moves the focus to the next item in the list.
    FocusNext,
    ///  Moves the focus to the previous item in the list.
    FocusPrev,
    /// Moves the focus to the first item in the list.
    FocusFirst,
    /// Moves the focus to the last item in the list.
    FocusLast,
    /// Deselects all items from the list
    ClearSelection,
    /// Scrolls the list to the given x and y position.
    Scroll(f32, f32),
}

/// A view for creating a list of items from an iterable signal.
pub struct List {
    /// The number of items in the list.
    num_items: usize,
    /// The set of selected items in the list.
    selection: Signal<BTreeSet<usize>>,
    /// Whether the list items are selectable.
    selectable: Signal<Selectable>,
    /// The index of the currently focused item in the list.
    focused: Signal<Option<usize>>,
    /// Whether the selection should follow the focus.
    selection_follows_focus: Signal<bool>,
    /// Whether pressing Space should select the focused item.
    space_selects_focused: Signal<bool>,
    /// Minimum number of selected items.
    min_selected: Signal<usize>,
    /// Maximum number of selected items.
    max_selected: Signal<usize>,
    /// The orientation of the list, either vertical or horizontal.
    orientation: Signal<Orientation>,
    /// Whether the scrollview should scroll to the cursor when the scrollbar is pressed.
    scroll_to_cursor: Signal<bool>,
    /// Whether the first item should be focused when the list gains focus with no selection.
    focus_first_item_on_focus_in: Signal<bool>,
    /// Callback called when a list item is selected.
    on_select: Option<Box<dyn Fn(&mut EventContext, usize)>>,
    /// Callback called when the focused list item changes.
    on_focus: Option<Box<dyn Fn(&mut EventContext, usize)>>,
    /// Callback called when the scrollview is scrolled.
    on_scroll: Option<Box<dyn Fn(&mut EventContext, f32, f32) + Send + Sync>>,
    /// The horizontal scroll position of the list.
    scroll_x: Signal<f32>,
    /// The vertical scroll position of the list.
    scroll_y: Signal<f32>,
    /// Whether the horizontal scrollbar should be visible.
    show_horizontal_scrollbar: Signal<bool>,
    /// Whether the vertical scrollbar should be visible.
    show_vertical_scrollbar: Signal<bool>,
    /// Whether focused list items should show focus visibility.
    focus_visibility: Signal<bool>,
    /// Returns the searchable text for each item index when type-ahead is enabled.
    type_ahead_text: Option<Box<dyn Fn(&mut EventContext, usize) -> Option<String>>>,
    /// Buffered type-ahead query built from rapid character input.
    type_ahead_buffer: String,
    /// Timestamp of the last accepted type-ahead character.
    type_ahead_last_input: Option<Instant>,
    /// Maximum elapsed time before resetting type-ahead buffer.
    type_ahead_timeout: Duration,
}

/// A binding handler that manages list item entities for a [List].
///
/// The user provides `Vec<T>` wrapped in an outer signal.
/// This handler creates internal signals for each item and maintains them.
/// Value changes to existing items update their internal signals (zero entity rebuilds).
/// Structural changes (add/remove/reorder) are handled by diffing values and rebuilding from the first changed position.
struct ListItemsBinding<T: 'static> {
    entity: Entity,
    list_entity: Entity,
    get_fn: Box<dyn Fn() -> Vec<T>>,
    item_content: Rc<dyn Fn(&mut Context, usize, Signal<T>)>,
    selection: Signal<BTreeSet<usize>>,
    focused: Signal<Option<usize>>,
    focus_visibility: Signal<bool>,
    /// Internal signals for each list item.
    item_signals: Vec<Signal<T>>,
    /// Entity IDs of the ListItem views.
    item_entities: Vec<Entity>,
    /// Previous values, used for value-based diffing.
    prev_values: Vec<T>,
    scope: Scope,
}

/// A binding handler that manages caller-provided list item entities for a [List].
///
/// This variant keeps list diffing and metadata updates but does not wrap items in [ListItem],
/// allowing callers to provide their own semantics and interaction behavior.
struct CustomListItemsBinding<T: 'static> {
    entity: Entity,
    list_entity: Entity,
    get_fn: Box<dyn Fn() -> Vec<T>>,
    item_content: Rc<dyn for<'a> Fn(&'a mut Context, usize, Signal<T>, Memo<bool>) -> Entity>,
    selection: Signal<BTreeSet<usize>>,
    /// Internal signals for each list item.
    item_signals: Vec<Signal<T>>,
    /// Entity IDs of caller-built item views.
    item_entities: Vec<Entity>,
    /// Previous values, used for value-based diffing.
    prev_values: Vec<T>,
    scope: Scope,
}

impl<T: PartialEq + Clone + 'static> ListItemsBinding<T> {
    fn create<S, V>(
        cx: &mut Context,
        list_entity: Entity,
        list: S,
        selection: Signal<BTreeSet<usize>>,
        focused: Signal<Option<usize>>,
        focus_visibility: Signal<bool>,
        item_content: Rc<dyn Fn(&mut Context, usize, Signal<T>)>,
    ) where
        S: SignalGet<V> + SignalWith<V> + Copy + 'static,
        V: Deref<Target = [T]> + Clone + 'static,
    {
        let entity = cx.entity_manager.create();
        let context_id = cx.context_id;
        cx.tree.add(entity, cx.current()).expect("Failed to add to tree");
        cx.tree.set_ignored(entity, true);

        let scope = Scope::new();
        let initial_values: Vec<T> = scope.enter(|| {
            UpdaterEffect::new(
                move || list.with(|list| list.deref().to_vec()),
                move |_new_value| {
                    SIGNAL_REBUILDS.with_borrow_mut(|set| {
                        set.insert(SignalRebuild { context_id, entity });
                    });
                },
            )
        });

        let mut binding = Self {
            entity,
            list_entity,
            get_fn: Box::new(move || list.with_untracked(|list| list.deref().to_vec())),
            item_content,
            selection,
            focused,
            focus_visibility,
            item_signals: Vec::new(),
            item_entities: Vec::new(),
            prev_values: Vec::new(),
            scope,
        };

        // Build initial items.
        for (index, value) in initial_values.iter().enumerate() {
            let signal = Signal::new(value.clone());
            let entity = binding.create_item_entity(cx, index, signal);
            binding.item_signals.push(signal);
            binding.item_entities.push(entity);
            binding.prev_values.push(value.clone());
        }
        binding.update_list_metadata(cx, initial_values.len());

        cx.bindings.insert(entity, Box::new(binding));

        let _: Handle<Self> =
            Handle { current: entity, entity, p: Default::default(), cx }.ignore();
    }

    fn update_list_metadata(&self, cx: &mut Context, len: usize) {
        if let Some(view) = cx.views.get_mut(&self.list_entity) {
            if let Some(list) = view.downcast_mut::<List>() {
                list.num_items = len;
                list.normalize_selection_state();
            }
        }
    }

    fn create_item_entity(&self, cx: &mut Context, index: usize, signal: Signal<T>) -> Entity {
        let mut created = Entity::null();
        let item_content = self.item_content.clone();
        let selection = self.selection;
        let focused = self.focused;
        let focus_visibility = self.focus_visibility;

        cx.with_current(self.entity, |cx| {
            created = ListItem::new(cx, index, signal, selection, focused, focus_visibility, {
                let item_content = item_content.clone();
                move |cx, index, item| (item_content)(cx, index, item)
            })
            .entity();
        });

        created
    }
}

impl<T: PartialEq + Clone + 'static> BindingHandler for ListItemsBinding<T> {
    fn update(&mut self, cx: &mut Context) {
        let new_values = (self.get_fn)();
        let new_len = new_values.len();

        // Find the first position where values differ.
        let first_diff = self
            .prev_values
            .iter()
            .zip(new_values.iter())
            .position(|(old, new)| old != new)
            .unwrap_or(self.prev_values.len().min(new_len));

        // Remove all entities from first_diff onward.
        for entity in self.item_entities.drain(first_diff..) {
            cx.remove(entity);
        }
        self.item_signals.truncate(first_diff);

        // Update existing signals or create new items from first_diff onward.
        for (i, value) in new_values[first_diff..].iter().enumerate() {
            let index = first_diff + i;
            if index < self.item_signals.len() {
                // Update existing signal
                self.item_signals[index].set(value.clone());
            } else {
                // Create new signal and item
                let signal = Signal::new(value.clone());
                let entity = self.create_item_entity(cx, index, signal);
                self.item_signals.push(signal);
                self.item_entities.push(entity);
            }
        }

        self.prev_values = new_values;
        self.update_list_metadata(cx, new_len);
    }

    fn remove(&self, _cx: &mut Context) {
        self.scope.dispose();
    }

    fn debug(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str("ListItemsBinding")
    }
}

impl<T: PartialEq + Clone + 'static> CustomListItemsBinding<T> {
    fn create<S, V>(
        cx: &mut Context,
        list_entity: Entity,
        list: S,
        selection: Signal<BTreeSet<usize>>,
        item_content: Rc<dyn for<'a> Fn(&'a mut Context, usize, Signal<T>, Memo<bool>) -> Entity>,
    ) where
        S: SignalGet<V> + SignalWith<V> + Copy + 'static,
        V: Deref<Target = [T]> + Clone + 'static,
    {
        let entity = cx.entity_manager.create();
        let context_id = cx.context_id;
        cx.tree.add(entity, cx.current()).expect("Failed to add to tree");
        cx.tree.set_ignored(entity, true);

        let scope = Scope::new();
        let initial_values: Vec<T> = scope.enter(|| {
            UpdaterEffect::new(
                move || list.with(|list| list.deref().to_vec()),
                move |_new_value| {
                    SIGNAL_REBUILDS.with_borrow_mut(|set| {
                        set.insert(SignalRebuild { context_id, entity });
                    });
                },
            )
        });

        let mut binding = Self {
            entity,
            list_entity,
            get_fn: Box::new(move || list.with_untracked(|list| list.deref().to_vec())),
            item_content,
            selection,
            item_signals: Vec::new(),
            item_entities: Vec::new(),
            prev_values: Vec::new(),
            scope,
        };

        // Build initial items.
        for (index, value) in initial_values.iter().enumerate() {
            let signal = Signal::new(value.clone());
            let entity = binding.create_item_entity(cx, index, signal);
            binding.item_signals.push(signal);
            binding.item_entities.push(entity);
            binding.prev_values.push(value.clone());
        }
        binding.update_list_metadata(cx, initial_values.len());

        cx.bindings.insert(entity, Box::new(binding));

        let _: Handle<Self> =
            Handle { current: entity, entity, p: Default::default(), cx }.ignore();
    }

    fn update_list_metadata(&self, cx: &mut Context, len: usize) {
        if let Some(view) = cx.views.get_mut(&self.list_entity) {
            if let Some(list) = view.downcast_mut::<List>() {
                list.num_items = len;
                list.normalize_selection_state();
            }
        }
    }

    fn create_item_entity(&self, cx: &mut Context, index: usize, signal: Signal<T>) -> Entity {
        let item_content = self.item_content.clone();
        let selection = self.selection;
        let mut created = Entity::null();

        cx.with_current(self.entity, |cx| {
            let is_selected = selection.map(move |selection| selection.contains(&index));
            created = (item_content)(cx, index, signal, is_selected);
        });

        created
    }
}

impl<T: PartialEq + Clone + 'static> BindingHandler for CustomListItemsBinding<T> {
    fn update(&mut self, cx: &mut Context) {
        let new_values = (self.get_fn)();
        let new_len = new_values.len();

        // Find the first position where values differ.
        let first_diff = self
            .prev_values
            .iter()
            .zip(new_values.iter())
            .position(|(old, new)| old != new)
            .unwrap_or(self.prev_values.len().min(new_len));

        // Remove all entities from first_diff onward.
        for entity in self.item_entities.drain(first_diff..) {
            cx.remove(entity);
        }
        self.item_signals.truncate(first_diff);

        // Update existing signals or create new items from first_diff onward.
        for (i, value) in new_values[first_diff..].iter().enumerate() {
            let index = first_diff + i;
            if index < self.item_signals.len() {
                self.item_signals[index].set(value.clone());
            } else {
                let signal = Signal::new(value.clone());
                let entity = self.create_item_entity(cx, index, signal);
                self.item_signals.push(signal);
                self.item_entities.push(entity);
            }
        }

        self.prev_values = new_values;
        self.update_list_metadata(cx, new_len);
    }

    fn remove(&self, _cx: &mut Context) {
        self.scope.dispose();
    }

    fn debug(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str("CustomListItemsBinding")
    }
}

impl List {
    fn set_focused_with_callback(&mut self, cx: &mut EventContext, focused: Option<usize>) {
        let previous = self.focused.get();
        self.focused.set(focused);

        if previous != focused {
            if let (Some(index), Some(callback)) = (focused, self.on_focus.as_ref()) {
                callback(cx, index);
            }
        }
    }

    fn find_type_ahead_match(
        &self,
        cx: &mut EventContext,
        query: &str,
        start_index: usize,
    ) -> Option<usize> {
        let get_text = self.type_ahead_text.as_ref()?;
        if self.num_items == 0 {
            return None;
        }

        for offset in 0..self.num_items {
            let index = (start_index + offset) % self.num_items;
            let item_text = get_text(cx, index)
                .map(|text| text.trim_start().to_lowercase())
                .unwrap_or_default();

            if !item_text.is_empty() && item_text.starts_with(query) {
                return Some(index);
            }
        }

        None
    }

    fn try_type_ahead(&mut self, cx: &mut EventContext, typed: char) -> bool {
        if self.type_ahead_text.is_none() || self.num_items == 0 {
            return false;
        }

        if typed.is_control() || typed.is_whitespace() {
            return false;
        }

        let now = Instant::now();
        let within_timeout = self
            .type_ahead_last_input
            .is_some_and(|last| now.saturating_duration_since(last) <= self.type_ahead_timeout);

        let ch = typed.to_lowercase().collect::<String>();
        let query = if within_timeout {
            let repeated_char_cycle = !self.type_ahead_buffer.is_empty()
                && self.type_ahead_buffer.chars().all(|c| c == typed.to_ascii_lowercase());

            if repeated_char_cycle {
                ch.clone()
            } else {
                format!("{}{}", self.type_ahead_buffer, ch)
            }
        } else {
            ch.clone()
        };

        let start_index =
            self.focused.get().map(|focused| (focused + 1) % self.num_items).unwrap_or(0);

        if let Some(index) = self.find_type_ahead_match(cx, &query, start_index) {
            self.type_ahead_buffer = query;
            self.type_ahead_last_input = Some(now);
            self.focus_visibility.set(true);
            self.set_focused_with_callback(cx, Some(index));

            if self.selection_follows_focus.get() {
                cx.emit(ListEvent::SelectFocused);
            }

            true
        } else {
            self.type_ahead_buffer.clear();
            self.type_ahead_last_input = Some(now);
            false
        }
    }

    fn selection_limits(&self) -> (usize, usize) {
        let mut min_selected = self.min_selected.get();
        let mut max_selected = self.max_selected.get();

        match self.selectable.get() {
            Selectable::None => {
                min_selected = 0;
                max_selected = 0;
            }

            Selectable::Single => {
                min_selected = min_selected.min(1);
                max_selected = 1;
            }

            Selectable::Multi => {}
        }

        max_selected = max_selected.min(self.num_items);
        min_selected = min_selected.min(max_selected);

        (min_selected, max_selected)
    }

    fn normalize_selection_state(&mut self) {
        let (min_selected, max_selected) = self.selection_limits();

        let mut selection = self.selection.get();
        selection.retain(|index| *index < self.num_items);

        while selection.len() > max_selected {
            if let Some(last) = selection.iter().next_back().copied() {
                selection.remove(&last);
            } else {
                break;
            }
        }

        if selection.len() < min_selected {
            for index in 0..self.num_items {
                selection.insert(index);
                if selection.len() >= min_selected {
                    break;
                }
            }
        }

        let mut focused = self.focused.get();
        if focused.is_some_and(|index| index >= self.num_items) {
            focused = self.num_items.checked_sub(1);
        }

        self.selection.set(selection);
        self.focused.set(focused);
    }

    /// Creates a new [List] view from a reactive or static list of values.
    ///
    /// `list` accepts any [`Res<V>`] source where `V` derefs to `[T]` — for example a
    /// `Signal<Vec<T>>` for a reactive list, or a plain `Vec<T>` for a static list.
    /// The list creates and manages internal signals for each item automatically.
    /// Value changes to existing items update their internal signals with zero entity rebuilds.
    /// Structural changes (add/remove/reorder) are handled by diffing values and rebuilding from the first changed position.
    pub fn new<S, V, T>(
        cx: &mut Context,
        list: S,
        item_content: impl 'static + Fn(&mut Context, usize, Signal<T>),
    ) -> Handle<Self>
    where
        S: Res<V> + 'static,
        V: Deref<Target = [T]> + Clone + 'static,
        T: PartialEq + Clone + 'static,
    {
        let content: Rc<dyn Fn(&mut Context, usize, Signal<T>)> = Rc::new(item_content);
        let selection = Signal::new(BTreeSet::default());
        let selectable = Signal::new(Selectable::None);
        let focused = Signal::new(None);
        let min_selected = Signal::new(0);
        let max_selected = Signal::new(usize::MAX);
        let orientation = Signal::new(Orientation::Vertical);
        let scroll_to_cursor = Signal::new(false);
        let focus_first_item_on_focus_in = Signal::new(true);
        let scroll_x = Signal::new(0.0);
        let scroll_y = Signal::new(0.0);
        let show_horizontal_scrollbar = Signal::new(true);
        let show_vertical_scrollbar = Signal::new(true);
        let focus_visibility = Signal::new(false);

        Self {
            num_items: 0,
            selection,
            selectable,
            focused,
            selection_follows_focus: Signal::new(false),
            space_selects_focused: Signal::new(true),
            min_selected,
            max_selected,
            orientation,
            scroll_to_cursor,
            focus_first_item_on_focus_in,
            on_select: None,
            on_focus: None,
            on_scroll: None,
            scroll_x,
            scroll_y,
            show_horizontal_scrollbar,
            show_vertical_scrollbar,
            focus_visibility,
            type_ahead_text: None,
            type_ahead_buffer: String::new(),
            type_ahead_last_input: None,
            type_ahead_timeout: Duration::from_millis(1000),
        }
        .build(cx, move |cx| {
            let list_entity = cx.current();

            Keymap::from(vec![
                (
                    KeyChord::new(Modifiers::empty(), Code::ArrowDown),
                    KeymapEntry::new("Focus Next", |cx| cx.emit(ListEvent::FocusNext)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::ArrowUp),
                    KeymapEntry::new("Focus Previous", |cx| cx.emit(ListEvent::FocusPrev)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::Home),
                    KeymapEntry::new("Focus First", |cx| cx.emit(ListEvent::FocusFirst)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::End),
                    KeymapEntry::new("Focus Last", |cx| cx.emit(ListEvent::FocusLast)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::Enter),
                    KeymapEntry::new("Select Focused", |cx| cx.emit(ListEvent::SelectFocused)),
                ),
            ])
            .build(cx);

            Binding::new(cx, orientation, move |cx| {
                let orientation = orientation.get();
                if orientation == Orientation::Horizontal {
                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowDown),
                        "Focus Next",
                    ));

                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowUp),
                        "Focus Previous",
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowRight),
                        KeymapEntry::new("Focus Next", |cx| cx.emit(ListEvent::FocusNext)),
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowLeft),
                        KeymapEntry::new("Focus Previous", |cx| cx.emit(ListEvent::FocusPrev)),
                    ));
                } else {
                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowRight),
                        "Focus Next",
                    ));

                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowLeft),
                        "Focus Previous",
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowDown),
                        KeymapEntry::new("Focus Next", |cx| cx.emit(ListEvent::FocusNext)),
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowUp),
                        KeymapEntry::new("Focus Previous", |cx| cx.emit(ListEvent::FocusPrev)),
                    ));
                }
            });

            let list_signal = list.to_signal(cx);
            ScrollView::new(cx, move |cx| {
                ListItemsBinding::create(
                    cx,
                    list_entity,
                    list_signal,
                    selection,
                    focused,
                    focus_visibility,
                    content.clone(),
                );
            })
            .show_horizontal_scrollbar(show_horizontal_scrollbar)
            .show_vertical_scrollbar(show_vertical_scrollbar)
            .scroll_to_cursor(scroll_to_cursor)
            .scroll_x(scroll_x)
            .scroll_y(scroll_y)
            .on_scroll(|cx, x, y| {
                if y.is_finite() {
                    cx.emit(ListEvent::Scroll(x, y));
                }
            });
        })
        .toggle_class("selectable", selectable.map(|s| *s != Selectable::None))
        .multiselectable(selectable.map(|s| *s == Selectable::Multi))
        .orientation(orientation)
        .navigable(true)
        .role(Role::ListBox)
    }

    /// Creates a new [List] view from a reactive or static list of values using caller-provided
    /// item views directly, without wrapping each item in a [ListItem].
    ///
    /// This keeps the list's diffing, keyboard, focus, and scrolling behavior while allowing
    /// custom item semantics.
    pub fn new_custom_items<S, V, T, H>(
        cx: &mut Context,
        list: S,
        item_content: impl 'static + for<'a> Fn(&'a mut Context, usize, Signal<T>) -> Handle<'a, H>,
    ) -> Handle<Self>
    where
        S: Res<V> + 'static,
        V: Deref<Target = [T]> + Clone + 'static,
        T: PartialEq + Clone + 'static,
        H: View,
    {
        Self::new_custom_items_with_selection(cx, list, move |cx, index, item, _is_selected| {
            item_content(cx, index, item)
        })
    }

    /// Creates a new [List] view from a reactive or static list of values using caller-provided
    /// item views directly, without wrapping each item in a [ListItem], and provides each item
    /// with a memo of whether it is currently selected in this list.
    pub fn new_custom_items_with_selection<S, V, T, H>(
        cx: &mut Context,
        list: S,
        item_content: impl 'static
        + for<'a> Fn(&'a mut Context, usize, Signal<T>, Memo<bool>) -> Handle<'a, H>,
    ) -> Handle<Self>
    where
        S: Res<V> + 'static,
        V: Deref<Target = [T]> + Clone + 'static,
        T: PartialEq + Clone + 'static,
        H: View,
    {
        let selection = Signal::new(BTreeSet::default());
        let selectable = Signal::new(Selectable::None);
        let focused = Signal::new(None);
        let min_selected = Signal::new(0);
        let max_selected = Signal::new(usize::MAX);
        let orientation = Signal::new(Orientation::Vertical);
        let scroll_to_cursor = Signal::new(false);
        let focus_first_item_on_focus_in = Signal::new(true);
        let scroll_x = Signal::new(0.0);
        let scroll_y = Signal::new(0.0);
        let show_horizontal_scrollbar = Signal::new(true);
        let show_vertical_scrollbar = Signal::new(true);
        let focus_visibility = Signal::new(false);

        let content: Rc<dyn for<'a> Fn(&'a mut Context, usize, Signal<T>, Memo<bool>) -> Entity> =
            Rc::new(move |cx, index, item, is_selected| {
                let is_focused = focused.map(move |focused| focused.is_some_and(|f| f == index));
                item_content(cx, index, item, is_selected)
                    .focusable(true)
                    .navigable(false)
                    .focused_with_visibility(is_focused, focus_visibility)
                    .entity()
            });

        Self {
            num_items: 0,
            selection,
            selectable,
            focused,
            selection_follows_focus: Signal::new(false),
            space_selects_focused: Signal::new(true),
            min_selected,
            max_selected,
            orientation,
            scroll_to_cursor,
            focus_first_item_on_focus_in,
            on_select: None,
            on_focus: None,
            on_scroll: None,
            scroll_x,
            scroll_y,
            show_horizontal_scrollbar,
            show_vertical_scrollbar,
            focus_visibility,
            type_ahead_text: None,
            type_ahead_buffer: String::new(),
            type_ahead_last_input: None,
            type_ahead_timeout: Duration::from_millis(1000),
        }
        .build(cx, move |cx| {
            let list_entity = cx.current();

            Keymap::from(vec![
                (
                    KeyChord::new(Modifiers::empty(), Code::ArrowDown),
                    KeymapEntry::new("Focus Next", |cx| cx.emit(ListEvent::FocusNext)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::ArrowUp),
                    KeymapEntry::new("Focus Previous", |cx| cx.emit(ListEvent::FocusPrev)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::Home),
                    KeymapEntry::new("Focus First", |cx| cx.emit(ListEvent::FocusFirst)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::End),
                    KeymapEntry::new("Focus Last", |cx| cx.emit(ListEvent::FocusLast)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::Enter),
                    KeymapEntry::new("Select Focused", |cx| cx.emit(ListEvent::SelectFocused)),
                ),
            ])
            .build(cx);

            Binding::new(cx, orientation, move |cx| {
                let orientation = orientation.get();
                if orientation == Orientation::Horizontal {
                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowDown),
                        "Focus Next",
                    ));

                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowUp),
                        "Focus Previous",
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowRight),
                        KeymapEntry::new("Focus Next", |cx| cx.emit(ListEvent::FocusNext)),
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowLeft),
                        KeymapEntry::new("Focus Previous", |cx| cx.emit(ListEvent::FocusPrev)),
                    ));
                } else {
                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowRight),
                        "Focus Next",
                    ));

                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowLeft),
                        "Focus Previous",
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowDown),
                        KeymapEntry::new("Focus Next", |cx| cx.emit(ListEvent::FocusNext)),
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowUp),
                        KeymapEntry::new("Focus Previous", |cx| cx.emit(ListEvent::FocusPrev)),
                    ));
                }
            });

            let list_signal = list.to_signal(cx);
            ScrollView::new(cx, move |cx| {
                CustomListItemsBinding::create(
                    cx,
                    list_entity,
                    list_signal,
                    selection,
                    content.clone(),
                );
            })
            .show_horizontal_scrollbar(show_horizontal_scrollbar)
            .show_vertical_scrollbar(show_vertical_scrollbar)
            .scroll_to_cursor(scroll_to_cursor)
            .scroll_x(scroll_x)
            .scroll_y(scroll_y)
            .on_scroll(|cx, x, y| {
                if y.is_finite() {
                    cx.emit(ListEvent::Scroll(x, y));
                }
            });
        })
        .toggle_class("selectable", selectable.map(|s| *s != Selectable::None))
        .multiselectable(selectable.map(|s| *s == Selectable::Multi))
        .orientation(orientation)
        .navigable(true)
    }
}

impl View for List {
    fn element(&self) -> Option<&'static str> {
        Some("list")
    }

    fn event(&mut self, cx: &mut EventContext, event: &mut Event) {
        event.map(|window_event, meta| {
            match window_event {
                WindowEvent::Press { mouse } => {
                    self.focus_visibility.set(!*mouse);
                }

                WindowEvent::FocusIn if meta.target == cx.current() => {
                    // Focus events originating at root are generated by keyboard navigation
                    // (e.g. Tab/Shift+Tab), so preserve visible focus in that case.
                    if meta.origin == Entity::root() {
                        self.focus_visibility.set(true);
                    }

                    let next_focused = focus_index_on_focus_in(
                        &self.selection.get(),
                        self.num_items,
                        self.focus_first_item_on_focus_in.get(),
                    );

                    if let Some(index) = next_focused {
                        // Force a transition so focused_with_visibility re-applies focus
                        // to the list item when focus enters the list container.
                        if self.focused.get() == Some(index) {
                            self.focused.set(None);
                        }
                        self.set_focused_with_callback(cx, Some(index));
                    }
                }

                WindowEvent::CharInput(c) => {
                    if *c == ' ' && meta.target == cx.current() && self.space_selects_focused.get()
                    {
                        cx.emit(ListEvent::SelectFocused);
                        meta.consume();
                    } else if self.try_type_ahead(cx, *c) {
                        meta.consume();
                    }
                }

                _ => {}
            }
        });

        event.take(|list_event, meta| match list_event {
            ListEvent::Select(index) => {
                let selectable = self.selectable.get();
                let (min_selected, max_selected) = self.selection_limits();
                let mut selection = self.selection.get();
                let mut focused = self.focused.get();
                match selectable {
                    Selectable::Single => {
                        if selection.contains(&index) {
                            if min_selected == 0 {
                                selection.clear();
                                focused = None;
                            }
                        } else {
                            selection.clear();
                            selection.insert(index);
                            focused = Some(index);
                            if let Some(on_select) = &self.on_select {
                                on_select(cx, index);
                            }
                        }
                    }

                    Selectable::Multi => {
                        // In multi-select mode, clicking an item should move focus to that item
                        // regardless of whether the click selects or deselects it.
                        focused = Some(index);

                        if selection.contains(&index) {
                            if selection.len() > min_selected {
                                selection.remove(&index);
                                if let Some(on_select) = &self.on_select {
                                    on_select(cx, index);
                                }
                            }
                        } else if selection.len() < max_selected {
                            selection.insert(index);
                            if let Some(on_select) = &self.on_select {
                                on_select(cx, index);
                            }
                        }
                    }

                    Selectable::None => {}
                }

                self.selection.set(selection);
                self.set_focused_with_callback(cx, focused);

                meta.consume();
            }

            ListEvent::SelectFocused => {
                if let Some(focused) = self.focused.get() {
                    self.focus_visibility.set(true);
                    cx.emit(ListEvent::Select(focused))
                }
                meta.consume();
            }

            ListEvent::Focus(index) => {
                if index < self.num_items {
                    self.focus_visibility.set(true);
                    self.set_focused_with_callback(cx, Some(index));
                }

                meta.consume();
            }

            ListEvent::ClearSelection => {
                let (min_selected, _) = self.selection_limits();
                if min_selected == 0 {
                    self.selection.set(BTreeSet::default());
                }
                meta.consume();
            }

            ListEvent::FocusNext => {
                println!(
                    "FocusNext received, num_items: {}, focused: {:?}",
                    self.num_items,
                    self.focused.get()
                );
                let mut focused = self.focused.get();
                let mut moved_focus = false;
                if let Some(f) = &mut focused {
                    if *f < self.num_items.saturating_sub(1) {
                        *f = f.saturating_add(1);
                        moved_focus = true;
                        if self.selection_follows_focus.get() {
                            cx.emit(ListEvent::SelectFocused);
                        }
                    }
                } else {
                    focused = Some(0);
                    moved_focus = true;
                    if self.selection_follows_focus.get() {
                        cx.emit(ListEvent::SelectFocused);
                    }
                }

                if moved_focus {
                    self.focus_visibility.set(true);
                }

                self.set_focused_with_callback(cx, focused);

                meta.consume();
            }

            ListEvent::FocusPrev => {
                let mut focused = self.focused.get();
                let mut moved_focus = false;
                if let Some(f) = &mut focused {
                    if *f > 0 {
                        *f = f.saturating_sub(1);
                        moved_focus = true;
                        if self.selection_follows_focus.get() {
                            cx.emit(ListEvent::SelectFocused);
                        }
                    }
                } else {
                    focused = Some(self.num_items.saturating_sub(1));
                    moved_focus = true;
                    if self.selection_follows_focus.get() {
                        cx.emit(ListEvent::SelectFocused);
                    }
                }

                if moved_focus {
                    self.focus_visibility.set(true);
                }

                self.set_focused_with_callback(cx, focused);

                meta.consume();
            }

            ListEvent::FocusFirst => {
                if self.num_items > 0 {
                    self.focus_visibility.set(true);
                    self.set_focused_with_callback(cx, Some(0));
                    if self.selection_follows_focus.get() {
                        cx.emit(ListEvent::SelectFocused);
                    }
                }

                meta.consume();
            }

            ListEvent::FocusLast => {
                if self.num_items > 0 {
                    self.focus_visibility.set(true);
                    self.set_focused_with_callback(cx, Some(self.num_items.saturating_sub(1)));
                    if self.selection_follows_focus.get() {
                        cx.emit(ListEvent::SelectFocused);
                    }
                }

                meta.consume();
            }

            ListEvent::Scroll(x, y) => {
                self.scroll_x.set(x);
                self.scroll_y.set(y);
                if let Some(callback) = &self.on_scroll {
                    (callback)(cx, x, y);
                }

                meta.consume();
            }
        })
    }
}

/// Modifiers for changing the behavior and selection state of a [List].
pub trait ListModifiers: Sized {
    /// Sets the selected items of the list from signal of type indices.
    fn selection<R>(self, selection: impl Res<R> + 'static) -> Self
    where
        R: Deref<Target = [usize]> + Clone + 'static;

    /// Sets the focused item of the list from a signal of an optional index.
    fn focused_index(self, focused: impl Res<Option<usize>> + 'static) -> Self;

    /// Sets the callback triggered when a [ListItem] is selected.
    fn on_select<F>(self, callback: F) -> Self
    where
        F: 'static + Fn(&mut EventContext, usize);

    /// Sets the callback triggered when a [ListItem] receives focus.
    fn on_focus<F>(self, callback: F) -> Self
    where
        F: 'static + Fn(&mut EventContext, usize);

    /// Set the selectable state of the [List].
    fn selectable<U: Into<Selectable> + Clone + 'static>(
        self,
        selectable: impl Res<U> + 'static,
    ) -> Self;

    /// Sets the minimum number of selected items.
    fn min_selected(self, min_selected: impl Res<usize> + 'static) -> Self;

    /// Sets the maximum number of selected items.
    fn max_selected(self, max_selected: impl Res<usize> + 'static) -> Self;

    /// Sets whether the selection should follow the focus.
    fn selection_follows_focus<U: Into<bool> + Clone + 'static>(
        self,
        flag: impl Res<U> + 'static,
    ) -> Self;

    /// Sets whether pressing Space should select the currently focused item.
    fn space_selects_focused<U: Into<bool> + Clone + 'static>(
        self,
        flag: impl Res<U> + 'static,
    ) -> Self;

    /// Sets the orientation of the list.
    fn horizontal<U: Into<bool> + Clone + 'static>(self, horizontal: impl Res<U> + 'static)
    -> Self;

    /// Sets whether the scrollbar should move to the cursor when pressed.
    fn scroll_to_cursor(self, flag: bool) -> Self;

    /// Sets whether the first item should be focused when the list gains focus with no selection.
    fn focus_first_item_on_focus_in(self, flag: impl Res<bool> + 'static) -> Self;

    /// Sets a callback which will be called when a scrollview is scrolled, either with the mouse wheel, touchpad, or using the scroll bars.
    fn on_scroll(
        self,
        callback: impl Fn(&mut EventContext, f32, f32) + 'static + Send + Sync,
    ) -> Self;

    /// Set the horizontal scroll position of the [ScrollView]. Accepts a value or signal of type an `f32` between 0 and 1.
    fn scroll_x(self, scrollx: impl Res<f32> + 'static) -> Self;

    /// Set the vertical scroll position of the [ScrollView]. Accepts a value or signal of type an `f32` between 0 and 1.
    fn scroll_y(self, scrolly: impl Res<f32> + 'static) -> Self;

    /// Sets whether the horizontal scrollbar should be visible.
    fn show_horizontal_scrollbar(self, flag: impl Res<bool> + 'static) -> Self;

    /// Sets whether the vertical scrollbar should be visible.
    fn show_vertical_scrollbar(self, flag: impl Res<bool> + 'static) -> Self;

    /// Enables type-ahead navigation by providing searchable text per item index.
    fn type_ahead_text<F>(self, callback: F) -> Self
    where
        F: 'static + Fn(&mut EventContext, usize) -> Option<String>;
}

impl ListModifiers for Handle<'_, List> {
    fn selection<R>(self, selection: impl Res<R> + 'static) -> Self
    where
        R: Deref<Target = [usize]> + Clone + 'static,
    {
        let selection = selection.to_signal(self.cx);
        self.bind(selection, move |handle| {
            selection.with(|selected_indices| {
                handle.modify(|list| {
                    let previous_focused = list.focused.get();
                    let mut selection = BTreeSet::default();
                    for idx in selected_indices.deref().iter().copied() {
                        selection.insert(idx);
                    }

                    let focused = previous_focused
                        .filter(|idx| *idx < list.num_items)
                        .or_else(|| selection.iter().next_back().copied());

                    list.selection.set(selection);
                    list.focused.set(focused);
                    list.normalize_selection_state();
                });
            });
        })
    }

    fn focused_index(self, focused: impl Res<Option<usize>> + 'static) -> Self {
        let focused = focused.to_signal(self.cx);
        self.bind(focused, move |handle| {
            let focused = focused.get();
            handle.modify(|list| {
                list.focused.set(normalize_focused_index(focused, list.num_items));
            });
        })
    }

    fn on_select<F>(self, callback: F) -> Self
    where
        F: 'static + Fn(&mut EventContext, usize),
    {
        self.modify(|list: &mut List| list.on_select = Some(Box::new(callback)))
    }

    fn on_focus<F>(self, callback: F) -> Self
    where
        F: 'static + Fn(&mut EventContext, usize),
    {
        self.modify(|list: &mut List| list.on_focus = Some(Box::new(callback)))
    }

    fn selectable<U: Into<Selectable> + Clone + 'static>(
        self,
        selectable: impl Res<U> + 'static,
    ) -> Self {
        let selectable = selectable.to_signal(self.cx);
        self.bind(selectable, move |handle| {
            let selectable = selectable.get();
            let s = selectable.into();
            handle.modify(|list: &mut List| {
                list.selectable.set(s);
                list.normalize_selection_state();
            });
        })
    }

    fn min_selected(self, min_selected: impl Res<usize> + 'static) -> Self {
        let min_selected = min_selected.to_signal(self.cx);
        self.bind(min_selected, move |handle| {
            let min_selected = min_selected.get();
            handle.modify(|list: &mut List| {
                list.min_selected.set(min_selected);
                list.normalize_selection_state();
            });
        })
    }

    fn max_selected(self, max_selected: impl Res<usize> + 'static) -> Self {
        let max_selected = max_selected.to_signal(self.cx);
        self.bind(max_selected, move |handle| {
            let max_selected = max_selected.get();
            handle.modify(|list: &mut List| {
                list.max_selected.set(max_selected);
                list.normalize_selection_state();
            });
        })
    }

    fn selection_follows_focus<U: Into<bool> + Clone + 'static>(
        self,
        flag: impl Res<U> + 'static,
    ) -> Self {
        let flag = flag.to_signal(self.cx);
        self.bind(flag, move |handle| {
            let selection_follows_focus = flag.get();
            let s = selection_follows_focus.into();
            handle.modify(|list: &mut List| list.selection_follows_focus.set(s));
        })
    }

    fn space_selects_focused<U: Into<bool> + Clone + 'static>(
        self,
        flag: impl Res<U> + 'static,
    ) -> Self {
        let flag = flag.to_signal(self.cx);
        self.bind(flag, move |handle| {
            let space_selects_focused = flag.get();
            let s = space_selects_focused.into();
            handle.modify(|list: &mut List| list.space_selects_focused.set(s));
        })
    }

    fn horizontal<U: Into<bool> + Clone + 'static>(
        self,
        horizontal: impl Res<U> + 'static,
    ) -> Self {
        let horizontal = horizontal.to_signal(self.cx);
        self.bind(horizontal, move |handle| {
            let horizontal = horizontal.get();
            let horizontal = horizontal.into();
            handle.modify(|list: &mut List| {
                list.orientation.set(if horizontal {
                    Orientation::Horizontal
                } else {
                    Orientation::Vertical
                });
            });
        })
    }

    fn scroll_to_cursor(self, flag: bool) -> Self {
        self.modify(|list| {
            list.scroll_to_cursor.set(flag);
        })
    }

    fn focus_first_item_on_focus_in(self, flag: impl Res<bool> + 'static) -> Self {
        let flag = flag.to_signal(self.cx);
        self.bind(flag, move |handle| {
            let focus_first_item_on_focus_in = flag.get();
            handle.modify(|list: &mut List| {
                list.focus_first_item_on_focus_in.set(focus_first_item_on_focus_in);
            });
        })
    }

    fn on_scroll(
        self,
        callback: impl Fn(&mut EventContext, f32, f32) + 'static + Send + Sync,
    ) -> Self {
        self.modify(|list: &mut List| list.on_scroll = Some(Box::new(callback)))
    }

    fn scroll_x(self, scrollx: impl Res<f32> + 'static) -> Self {
        let scrollx = scrollx.to_signal(self.cx);
        self.bind(scrollx, move |handle| {
            let scrollx = scrollx.get();
            handle.modify(|list| {
                list.scroll_x.set(scrollx);
            });
        })
    }

    fn scroll_y(self, scrolly: impl Res<f32> + 'static) -> Self {
        let scrolly = scrolly.to_signal(self.cx);
        self.bind(scrolly, move |handle| {
            let scrolly = scrolly.get();
            handle.modify(|list| {
                list.scroll_y.set(scrolly);
            });
        })
    }

    fn show_horizontal_scrollbar(self, flag: impl Res<bool> + 'static) -> Self {
        let flag = flag.to_signal(self.cx);
        self.bind(flag, move |handle| {
            let show_scrollbar = flag.get();
            handle.modify(|list| {
                list.show_horizontal_scrollbar.set(show_scrollbar);
            });
        })
    }

    fn show_vertical_scrollbar(self, flag: impl Res<bool> + 'static) -> Self {
        let flag = flag.to_signal(self.cx);
        self.bind(flag, move |handle| {
            let show_scrollbar = flag.get();
            handle.modify(|list| {
                list.show_vertical_scrollbar.set(show_scrollbar);
            });
        })
    }

    fn type_ahead_text<F>(self, callback: F) -> Self
    where
        F: 'static + Fn(&mut EventContext, usize) -> Option<String>,
    {
        self.modify(|list: &mut List| list.type_ahead_text = Some(Box::new(callback)))
    }
}

/// A view which represents a selectable item within a list.
pub struct ListItem {
    selected: Memo<bool>,
}

impl ListItem {
    /// Create a new [ListItem] view.
    pub fn new<'a, T: Clone + 'static, M: SignalGet<T> + 'static>(
        cx: &'a mut Context,
        index: usize,
        item: M,
        selection: impl SignalMap<BTreeSet<usize>> + SignalGet<BTreeSet<usize>>,
        focused: impl SignalMap<Option<usize>>,
        focus_visibility: impl Res<bool> + Copy + 'static,
        item_content: impl 'static + Fn(&mut Context, usize, M),
    ) -> Handle<'a, Self> {
        let is_focused =
            focused.map(move |focused| focused.as_ref().is_some_and(|f| *f == index)).get();
        let focused_signal =
            focused.map(move |focused| focused.as_ref().is_some_and(|f| *f == index));
        let is_selected = selection.map(move |selection| selection.contains(&index));
        Self { selected: is_selected }
            .build(cx, move |cx| {
                item_content(cx, index, item);
            })
            .role(Role::ListBoxOption)
            .focusable(true)
            .navigable(false)
            .toggle_class("focused", focused_signal)
            .focused_with_visibility(focused_signal, focus_visibility)
            .checked(selection.map(move |selection| selection.contains(&index)))
            .bind(focused_signal, move |handle| {
                let focused = focused_signal.get();
                if focused != is_focused {
                    handle.cx.emit(ScrollEvent::ScrollToView(handle.entity()));
                }
            })
            .on_press(move |cx| cx.emit(ListEvent::Select(index)))
    }
}

impl View for ListItem {
    fn element(&self) -> Option<&'static str> {
        Some("list-item")
    }

    fn event(&mut self, cx: &mut EventContext, event: &mut Event) {
        event.map(|window_event, _| match window_event {
            WindowEvent::GeometryChanged(geo) => {
                if self.selected.get() && geo.contains(GeoChanged::HEIGHT_CHANGED) {
                    cx.emit(ScrollEvent::ScrollToView(cx.current()));
                }
            }
            _ => {}
        });
    }
}

fn focus_index_on_focus_in(
    selection: &BTreeSet<usize>,
    num_items: usize,
    focus_first_item_on_focus_in: bool,
) -> Option<usize> {
    selection
        .iter()
        .copied()
        .find(|index| *index < num_items)
        .or_else(|| focus_first_item_on_focus_in.then_some(0).filter(|_| num_items > 0))
}

fn normalize_focused_index(focused: Option<usize>, num_items: usize) -> Option<usize> {
    focused.filter(|index| *index < num_items)
}

#[cfg(test)]
mod tests {
    use super::{focus_index_on_focus_in, normalize_focused_index};
    use std::collections::BTreeSet;

    #[test]
    fn focuses_selected_item_on_focus_in() {
        let mut selection = BTreeSet::new();
        selection.insert(3);

        assert_eq!(focus_index_on_focus_in(&selection, 5, false), Some(3));
    }

    #[test]
    fn can_leave_focus_empty_when_nothing_is_selected() {
        let selection = BTreeSet::new();

        assert_eq!(focus_index_on_focus_in(&selection, 5, false), None);
    }

    #[test]
    fn falls_back_to_first_item_when_enabled() {
        let selection = BTreeSet::new();

        assert_eq!(focus_index_on_focus_in(&selection, 5, true), Some(0));
    }

    #[test]
    fn keeps_focused_index_when_in_range() {
        assert_eq!(normalize_focused_index(Some(3), 5), Some(3));
    }

    #[test]
    fn clears_focused_index_when_out_of_range() {
        assert_eq!(normalize_focused_index(Some(5), 5), None);
    }
}