//! Combobox widget — an editable text field with a click-toggled drop-down list

//! of options. A blend of [`crate::widgets::drop_down::DropDown`] (the list of

//! options + click-to-select-by-index + `on_select` callback) and

//! [`crate::widgets::text_input::TextInput`] (the editable text field on top: the

//! user may type a free value, with `get_text_changeset` insertion + backspace

//! deletion). The open/close show-hide mirrors

//! [`crate::widgets::popover::Popover`] (an absolutely-positioned panel toggled

//! via `set_css_property(display)`), but the panel here holds a list of clickable

//! options rather than a single native menu popup.

//!

//! Structure: a `position: relative` wrapper containing a focusable *input field*

//! (a text node + a drop-down arrow) followed by an absolutely-positioned

//! *options list*, hidden by default (`display: none`). A single shared

//! [`RefAny`] holding the [`ComboBoxStateWrapper`] is attached to every callback

//! (the field's toggle/text-input/key-down handlers and each option's click

//! handler) so all of them read and mutate the *same* state — clicking the field

//! flips `open` and shows/hides the list; clicking an option fills the field with

//! the option's label (`change_node_text`), sets `selected`, closes the list, and

//! invokes the optional user `on_select(state)` with the new [`ComboBoxState`].

//! The clicked option's index is derived from its position (counting previous

//! siblings), exactly like the index-by-position approach used elsewhere.

//!

//! TODO2 — type-to-filter is NOT implemented. Live "filter-as-you-type" requires

//! the option list to be RE-RENDERED (a DOM rebuild) from the typed text on every

//! keystroke. Azul widget handlers can only patch *live* state through

//! `info.set_css_property` / `info.change_node_text` (show/hide/restyle/retext an

//! existing node) — they cannot add/remove DOM nodes, so the visible option set

//! cannot be re-filtered from a handler with the tools the other widgets use. The

//! field is therefore genuinely *editable* (you can type a free value, which is

//! reported in [`ComboBoxState::text`]), and selecting from the *full* list works

//! — but the list does not shrink as you type. A future revision could rebuild

//! the list via a full relayout (`Update::RefreshDom`) driven by a user callback

//! that owns the items, once that is runtime-verifiable.

//!

//! TODO2 — like [`Popover`], the list is placed at a fixed offset below the field

//! (it does not measure the field's height, flip near a screen edge, escape an

//! `overflow: hidden` ancestor, or raise its z-order — it relies on being the

//! later sibling to paint on top). There is no click-outside / blur dismissal

//! (closing on focus-lost races the option click and could swallow the

//! selection); the list closes on selection or on clicking the field again.

//!

//! Key types: [`ComboBox`], [`ComboBoxState`], [`ComboBoxOnSelect`].

use alloc::{string::String, vec::Vec};

use azul_core::{

    callbacks::{CoreCallback, CoreCallbackData, Update},

    dom::{

        Dom, DomVec, EventFilter, FocusEventFilter, HoverEventFilter, IdOrClass, IdOrClass::Class,

        IdOrClassVec, TabIndex,

    },

    refany::{OptionRefAny, RefAny},

    window::VirtualKeyCode,

};

use azul_css::dynamic_selector::{CssPropertyWithConditions, CssPropertyWithConditionsVec};

use azul_css::{

    props::{

        basic::{color::ColorU, font::{StyleFontFamily, StyleFontFamilyVec}, StyleFontSize},

        layout::{LayoutDisplay, LayoutPosition, LayoutFlexGrow, LayoutMinWidth, LayoutFlexDirection, LayoutAlignItems, LayoutPaddingTop, LayoutPaddingBottom, LayoutPaddingLeft, LayoutPaddingRight, LayoutTop, LayoutLeft},

        property::{CssProperty, *},

        style::{StyleBackgroundContent, StyleBackgroundContentVec, StyleCursor, LayoutBorderTopWidth, LayoutBorderBottomWidth, LayoutBorderLeftWidth, LayoutBorderRightWidth, StyleBorderTopStyle, BorderStyle, StyleBorderBottomStyle, StyleBorderLeftStyle, StyleBorderRightStyle, StyleBorderTopColor, StyleBorderBottomColor, StyleBorderLeftColor, StyleBorderRightColor, StyleBorderTopLeftRadius, StyleBorderTopRightRadius, StyleBorderBottomLeftRadius, StyleBorderBottomRightRadius, StyleTextColor, StyleTextAlign, StyleUserSelect},

    },

    impl_option_inner, AzString, StringVec,

};

use crate::callbacks::{Callback, CallbackInfo};

static COMBOBOX_WRAPPER_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-combobox"))];

static COMBOBOX_INPUT_CLASS: &[IdOrClass] = &[Class(AzString::from_const_str(

    "__azul-native-combobox-input",

))];

static COMBOBOX_TEXT_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-combobox-text"))];

static COMBOBOX_ARROW_CLASS: &[IdOrClass] = &[Class(AzString::from_const_str(

    "__azul-native-combobox-arrow",

))];

static COMBOBOX_LIST_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-combobox-list"))];

static COMBOBOX_OPTION_CLASS: &[IdOrClass] = &[Class(AzString::from_const_str(

    "__azul-native-combobox-option",

))];

const SYSTEM_UI_STR: AzString = AzString::from_const_str("system:ui");

const SYSTEM_UI_FAMILIES: &[StyleFontFamily] = &[StyleFontFamily::System(SYSTEM_UI_STR)];

const SYSTEM_UI_FAMILY: StyleFontFamilyVec =

    StyleFontFamilyVec::from_const_slice(SYSTEM_UI_FAMILIES);

// ---- layout (logical px) ----

/// Fixed vertical offset of the list below the wrapper's top edge (a

/// simplification - see the module-level `TODO2`; the field is ~26px tall).

const LIST_OFFSET_Y: isize = 28;

/// Minimum width of the field and the list.

const MIN_WIDTH: isize = 160;

const RADIUS: isize = 4;

const ARROW_FONT_SIZE_PX: isize = 18;

// ---- colours ----

const WHITE: ColorU = ColorU { r: 255, g: 255, b: 255, a: 255 };

const BORDER_COLOR: ColorU = ColorU { r: 172, g: 172, b: 172, a: 255 }; // #acacac

const BORDER_FOCUS: ColorU = ColorU { r: 66, g: 134, b: 244, a: 255 }; // #4286f4

const TEXT_COLOR: ColorU = ColorU { r: 51, g: 51, b: 51, a: 255 }; // #333333

const OPTION_HOVER_BG: ColorU = ColorU { r: 234, g: 244, b: 252, a: 255 }; // #eaf4fc

const WHITE_BG_ITEMS: &[StyleBackgroundContent] = &[StyleBackgroundContent::Color(WHITE)];

const WHITE_BG_VEC: StyleBackgroundContentVec =

    StyleBackgroundContentVec::from_const_slice(WHITE_BG_ITEMS);

const OPTION_HOVER_BG_ITEMS: &[StyleBackgroundContent] =

    &[StyleBackgroundContent::Color(OPTION_HOVER_BG)];

const OPTION_HOVER_BG_VEC: StyleBackgroundContentVec =

    StyleBackgroundContentVec::from_const_slice(OPTION_HOVER_BG_ITEMS);

/// Callback invoked when an option is chosen. The [`ComboBoxState`] carries the

/// new `selected` index and the field `text` (set to the chosen label).

pub type ComboBoxOnSelectCallbackType = extern "C" fn(RefAny, CallbackInfo, ComboBoxState) -> Update;

impl_widget_callback!(

    ComboBoxOnSelect,

    OptionComboBoxOnSelect,

    ComboBoxOnSelectCallback,

    ComboBoxOnSelectCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        ComboBoxOnSelectCallback,

    info_ty:        CallbackInfo,

    return_ty:      Update,

    default_ret:    Update::DoNothing,

    invoker_static: COMBOBOX_ON_SELECT_INVOKER,

    invoker_ty:     AzComboBoxOnSelectCallbackInvoker,

    thunk_fn:       az_combobox_on_select_callback_thunk,

    setter_fn:      AzApp_setComboBoxOnSelectCallbackInvoker,

    from_handle_fn: AzComboBoxOnSelectCallback_createFromHostHandle,

    extra_args:     [ state: ComboBoxState ],

}

/// An editable filtered-select widget: a text field plus a click-toggled list of

/// options.

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C)]

pub struct ComboBox {

    /// Runtime state (`open`/`selected`/`text`) plus the item list and the

    /// optional select callback.

    pub combo_state: ComboBoxStateWrapper,

    /// Greyed text shown in the field when no value has been typed/selected.

    pub placeholder: AzString,

    /// Style of the outer wrapper (the `position: relative` context).

    pub wrapper_style: CssPropertyWithConditionsVec,

    /// Style of the clickable, focusable, editable input field.

    pub field_style: CssPropertyWithConditionsVec,

    /// Style of the text inside the field.

    pub text_style: CssPropertyWithConditionsVec,

    /// Style of the drop-down arrow icon on the right of the field.

    pub arrow_style: CssPropertyWithConditionsVec,

    /// Style of each option row inside the list panel.

    pub option_style: CssPropertyWithConditionsVec,

    /// Extra properties appended to the options-list panel style. The

    /// open/close `display` toggle stays widget-managed; anything here wins

    /// over the built-in panel style (inline properties resolve last-wins).

    pub list_style: CssPropertyWithConditionsVec,

}

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C)]

pub struct ComboBoxStateWrapper {

    /// The mutable per-interaction state passed to `on_select`.

    pub inner: ComboBoxState,

    /// The full set of selectable options (rendered into the list).

    pub items: StringVec,

    /// Optional: function to call when an option is selected.

    pub on_select: OptionComboBoxOnSelect,

}

impl Default for ComboBoxStateWrapper {

}

/// The live state of a [`ComboBox`]: whether the list is open, the currently

/// selected index, and the current (editable) field text.

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C)]

pub struct ComboBoxState {

    /// `true` = list shown, `false` (default) = list hidden.

    pub open: bool,

    /// Zero-based index of the most recently selected option.

    pub selected: usize,

    /// The current text shown in the field (typed or set from a selection).

    pub text: AzString,

}

impl Default for ComboBoxState {

}

// ---- styles ----

/// Wrapper: an inline-block positioning context so the absolutely-positioned list

/// is placed relative to it.

static COMBOBOX_WRAPPER_STYLE: &[CssPropertyWithConditions] = &[

    CssPropertyWithConditions::simple(CssProperty::const_display(LayoutDisplay::InlineBlock)),

    CssPropertyWithConditions::simple(CssProperty::const_position(LayoutPosition::Relative)),

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(0))),

    CssPropertyWithConditions::simple(CssProperty::const_min_width(LayoutMinWidth::const_px(

        MIN_WIDTH,

    ))),

    CssPropertyWithConditions::simple(CssProperty::const_font_size(StyleFontSize::const_px(13))),

    CssPropertyWithConditions::simple(CssProperty::const_font_family(SYSTEM_UI_FAMILY)),

];

/// The clickable, focusable, editable input field (text + arrow).

static COMBOBOX_INPUT_STYLE: &[CssPropertyWithConditions] = &[

    CssPropertyWithConditions::simple(CssProperty::const_display(LayoutDisplay::Flex)),

    CssPropertyWithConditions::simple(CssProperty::const_flex_direction(LayoutFlexDirection::Row)),

    CssPropertyWithConditions::simple(CssProperty::const_align_items(LayoutAlignItems::Center)),

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(0))),

    CssPropertyWithConditions::simple(CssProperty::const_cursor(StyleCursor::Text)),

    // padding: 3px 4px

    CssPropertyWithConditions::simple(CssProperty::const_padding_top(LayoutPaddingTop::const_px(3))),

    CssPropertyWithConditions::simple(CssProperty::const_padding_bottom(

        LayoutPaddingBottom::const_px(3),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_padding_left(LayoutPaddingLeft::const_px(

        4,

    ))),

    CssPropertyWithConditions::simple(CssProperty::const_padding_right(

        LayoutPaddingRight::const_px(4),

    )),

    // border: 1px solid #acacac

    CssPropertyWithConditions::simple(CssProperty::const_border_top_width(

        LayoutBorderTopWidth::const_px(1),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_width(

        LayoutBorderBottomWidth::const_px(1),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_left_width(

        LayoutBorderLeftWidth::const_px(1),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_right_width(

        LayoutBorderRightWidth::const_px(1),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_top_style(StyleBorderTopStyle {

        inner: BorderStyle::Solid,

    })),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_style(

        StyleBorderBottomStyle {

            inner: BorderStyle::Solid,

        },

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_left_style(StyleBorderLeftStyle {

        inner: BorderStyle::Solid,

    })),

    CssPropertyWithConditions::simple(CssProperty::const_border_right_style(

        StyleBorderRightStyle {

            inner: BorderStyle::Solid,

        },

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_top_color(StyleBorderTopColor {

        inner: BORDER_COLOR,

    })),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_color(

        StyleBorderBottomColor {

            inner: BORDER_COLOR,

        },

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_left_color(StyleBorderLeftColor {

        inner: BORDER_COLOR,

    })),

    CssPropertyWithConditions::simple(CssProperty::const_border_right_color(

        StyleBorderRightColor {

            inner: BORDER_COLOR,

        },

    )),

    // border-radius: 4px

    CssPropertyWithConditions::simple(CssProperty::const_border_top_left_radius(

        StyleBorderTopLeftRadius::const_px(RADIUS),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_top_right_radius(

        StyleBorderTopRightRadius::const_px(RADIUS),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_left_radius(

        StyleBorderBottomLeftRadius::const_px(RADIUS),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_right_radius(

        StyleBorderBottomRightRadius::const_px(RADIUS),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_background_content(WHITE_BG_VEC)),

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

        inner: TEXT_COLOR,

    })),

    // focus: highlight border

    CssPropertyWithConditions::on_focus(CssProperty::const_border_top_color(StyleBorderTopColor {

        inner: BORDER_FOCUS,

    })),

    CssPropertyWithConditions::on_focus(CssProperty::const_border_bottom_color(

        StyleBorderBottomColor {

            inner: BORDER_FOCUS,

        },

    )),

    CssPropertyWithConditions::on_focus(CssProperty::const_border_left_color(StyleBorderLeftColor {

        inner: BORDER_FOCUS,

    })),

    CssPropertyWithConditions::on_focus(CssProperty::const_border_right_color(

        StyleBorderRightColor {

            inner: BORDER_FOCUS,

        },

    )),

];

/// The editable text inside the field - takes the remaining horizontal space.

static COMBOBOX_TEXT_STYLE: &[CssPropertyWithConditions] = &[

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(1))),

    CssPropertyWithConditions::simple(CssProperty::const_text_align(StyleTextAlign::Left)),

    CssPropertyWithConditions::simple(CssProperty::const_padding_right(

        LayoutPaddingRight::const_px(4),

    )),

];

/// The drop-down arrow icon on the right of the field.

static COMBOBOX_ARROW_STYLE: &[CssPropertyWithConditions] = &[

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(0))),

    CssPropertyWithConditions::simple(CssProperty::const_font_size(StyleFontSize::const_px(

        ARROW_FONT_SIZE_PX,

    ))),

    CssPropertyWithConditions::simple(CssProperty::user_select(StyleUserSelect::None)),

];

/// Builds the floating options-list style. Only the `display` (open vs closed)

/// differs; all positioning/visual props are present in both so the runtime

/// `set_css_property(display)` toggle has everything it needs (mirroring the

/// popover/accordion approach).

    } else {

    };

            MIN_WIDTH,

        ))),

        // border: 1px solid #acacac

        )),

        )),

        )),

        )),

        )),

        )),

        )),

        )),

        // border-radius: 4px

        )),

        )),

    ])

/// Per-option row style: a padded, pointer-cursor block highlighted on hover.

static COMBOBOX_OPTION_STYLE: &[CssPropertyWithConditions] = &[

    CssPropertyWithConditions::simple(CssProperty::const_display(LayoutDisplay::Block)),

    CssPropertyWithConditions::simple(CssProperty::const_padding_top(LayoutPaddingTop::const_px(6))),

    CssPropertyWithConditions::simple(CssProperty::const_padding_bottom(

        LayoutPaddingBottom::const_px(6),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_padding_left(LayoutPaddingLeft::const_px(

        10,

    ))),

    CssPropertyWithConditions::simple(CssProperty::const_padding_right(

        LayoutPaddingRight::const_px(10),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_cursor(StyleCursor::Pointer)),

    CssPropertyWithConditions::simple(CssProperty::user_select(StyleUserSelect::None)),

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

        inner: TEXT_COLOR,

    })),

    CssPropertyWithConditions::on_hover(CssProperty::const_background_content(OPTION_HOVER_BG_VEC)),

];

impl ComboBox {

    /// Creates a new combobox with the given options (no callback, nothing typed).

    /// Creates an empty combobox.

    /// Sets the initially-selected option index.

    #[inline]

    /// Builder-style setter for the initially-selected index.

    #[inline]

    /// Sets the initial (editable) field text.

    #[inline]

    /// Builder-style setter for the initial field text.

    #[inline]

    /// Sets the greyed placeholder shown when the field is empty.

    #[inline]

    /// Builder-style setter for the placeholder.

    #[inline]

    /// Sets the callback invoked when an option is selected.

    #[inline]

    /// Builder-style setter for the select callback.

    #[inline]

    /// Replaces `self` with a default (empty) combobox and returns the original.

    #[inline]

    /// Renders the combobox into a [`Dom`] subtree with the `__azul-native-combobox`

    /// class.

        // Initial field text: the typed/selected text if present, else the

        // placeholder (a simplification — there is no separate placeholder node,

        // so the placeholder is just the initial label and is replaced on the

        // first keystroke or selection).

        } else {

        };

        // ONE shared RefAny: the field handlers and every option handler all

        // read/mutate the same ComboBoxStateWrapper (the text_input shared-state

        // pattern), so open/selected/text stay in sync across interactions.

        // The focusable, editable input field. Clicking it toggles the list

        // (Hover::MouseUp) and focuses it; typing edits the text node

        // (Focus::TextInput / VirtualKeyDown), mirroring text_input.

                ]

            )

        // Build the option rows. Each carries a CLONE of the shared state so its

        // click handler can mutate selected/open and read the chosen label.

        // Widget-managed panel style (open/close display toggle) + caller

        // extras appended last so they win (inline resolution is last-wins).

        } else {

        };

            // children: [field, list] — the list is the field's next sibling.

}

impl Default for ComboBox {

}

/// Field click handler. The hit node is the field; its next sibling is the list.

/// Flips `open` on the shared state and shows/hides the list via `display`.

    };

        };

    };

    // TODO2: shows/hides the list by toggling `display` via set_css_property; the

    // display:none/block relayout itself is not GUI-verified in this build.

    } else {

    };

/// Field text-input handler - appends the typed character(s) to the editable

/// field text (mirroring `text_input`). Does NOT re-filter the list (see the

/// module-level type-to-filter `TODO2`).

    // field -> label `<p>` -> bare text leaf: the label convention keeps the

    // styling on the block box, so the re-textable node is one level deeper.

    };

/// Field key-down handler - implements backspace deletion (mirroring `text_input`).

    // field -> label `<p>` -> bare text leaf (see `on_combobox_text_input_inner`).

    };

/// Option click handler. The hit node is the clicked option's `<p>`; its index is

/// the number of previous siblings. Its parent is the list; the list's parent is

/// the wrapper, whose first child is the field, whose first child is the label

/// `<p>`, whose only child is the text node.

/// Fills the field with the option's label, sets `selected`, closes the list, and

/// invokes the optional user callback.

    // index = number of previous siblings.

    };

    };

    };

    };

    };

        };

        };

            }

        };

    };

    // Fill the field with the chosen label and close the list.

impl From<ComboBox> for Dom {

}

#[cfg(all(test, feature = "std"))]

#[allow(clippy::too_many_lines)]

// `redundant_closure`: NOT redundant here. `run()` takes

// `impl FnOnce(RefAny, CallbackInfo) -> R`; `CallbackInfo` carries an elided

// lifetime, so the bound is higher-ranked (`for<'a> FnOnce(_, CallbackInfo<'a>)`).

// The handlers are `extern "C" fn` items, which do NOT satisfy a higher-ranked

// `FnOnce` bound — passing one bare fails to compile with E0277. The `|r, ci| f(r, ci)`

// wrapper is what makes the coercion happen and must stay.

#[allow(clippy::redundant_closure)]

mod autotest_generated {

    use std::{

        cell::{Cell, RefCell},

        collections::{BTreeMap, HashMap},

        sync::{Arc, Mutex},

    };

    use azul_core::{

        dom::{DomId, DomNodeId, NodeId, NodeType},

        geom::{LogicalRect, OptionLogicalPosition},

        gl::OptionGlContextPtr,

        hit_test::ScrollPosition,

        resources::RendererResources,

        styled_dom::{NodeHierarchyItemId, StyledDom},

        window::{MonitorVec, RawWindowHandle},

    };

    use azul_css::system::SystemStyle;

    use rust_fontconfig::FcFontCache;

    use super::*;

    #[cfg(feature = "icu")]

    use crate::icu::IcuLocalizerHandle;

    use crate::{

        callbacks::{CallbackChange, CallbackInfoRefData, ExternalSystemCallbacks},

        managers::text_input::PendingTextEdit,

        solver3::{display_list::DisplayList, layout_tree::LayoutTree},

        window::{DomLayoutResult, LayoutWindow},

        window_state::FullWindowState,

    };

    // ------------------------------------------------------------------

    // Fixtures / helpers

    // ------------------------------------------------------------------

    /// A `StringVec` of options from string literals.

    fn sv(items: &[&str]) -> StringVec {

        StringVec::from_vec(items.iter().map(|s| AzString::from(*s)).collect())

    }

    /// True if `node` carries the CSS class `name`.

    fn has_class(node: &Dom, name: &str) -> bool {

        node.root

            .get_ids_and_classes()

            .as_ref()

            .iter()

            .any(|c| matches!(c, Class(s) if s.as_str() == name))

    }

    /// The text of a text node, looking through the `<p>` block wrapper the

    /// label convention mandates (`p > text`).

    fn text_of(node: &Dom) -> Option<&str> {

        match node.root.get_node_type() {

            NodeType::Text(s) => Some(s.as_ref().as_str()),

            NodeType::P => match node.children.as_ref() {

                [only] => match only.root.get_node_type() {

                    NodeType::Text(s) => Some(s.as_ref().as_str()),

                    _ => None,

                },

                _ => None,

            },

            _ => None,

        }

    }

    /// The icon name of a `NodeType::Icon` node.

    fn icon_of(node: &Dom) -> Option<&str> {

        match node.root.get_node_type() {

            NodeType::Icon(s) => Some(s.as_ref().as_str()),

            _ => None,

        }

    }

    /// The `display` value in a node's *inline* style, if it sets one.

    fn inline_display(node: &Dom) -> Option<LayoutDisplay> {

        node.root

            .style

            .iter_inline_properties()

            .find_map(|(p, _)| match p {

                CssProperty::Display(v) => v.get_property().copied(),

                _ => None,

            })

    }

    /// The `display` declared in a built style vec.

    fn display_of(props: &CssPropertyWithConditionsVec) -> Option<LayoutDisplay> {

        props.as_ref().iter().find_map(|p| match &p.property {

            CssProperty::Display(v) => v.get_property().copied(),

            _ => None,

        })

    }

    /// The `position` declared in a built style vec.

    fn position_of(props: &CssPropertyWithConditionsVec) -> Option<LayoutPosition> {

        props.as_ref().iter().find_map(|p| match &p.property {

            CssProperty::Position(v) => v.get_property().copied(),

            _ => None,

        })

    }

    /// `(field, list)` of a rendered combobox DOM.

    fn parts(dom: &Dom) -> (&Dom, &Dom) {

        let children = dom.children.as_ref();

        assert_eq!(children.len(), 2, "a combobox is exactly [field, list]");

        (&children[0], &children[1])

    }

    /// Flattened indices of every node carrying `class`, in tree order. Used

    /// instead of hard-coded indices so the tests do not encode the DOM

    /// flattening order.

    fn nodes_with_class(styled: &StyledDom, class: &str) -> Vec<usize> {

        styled

            .node_data

            .as_ref()

            .iter()

            .enumerate()

            .filter(|(_, nd)| {

                nd.get_ids_and_classes()

                    .as_ref()

                    .iter()

                    .any(|c| matches!(c, Class(s) if s.as_str() == class))

            })

            .map(|(i, _)| i)

            .collect()

    }

    /// A styled `ComboBox::new(items).dom()` plus the flattened index of every

    /// node the handlers navigate to.

    struct Fixture {

        styled: StyledDom,

        wrapper: usize,

        field: usize,

        text: usize,

        list: usize,

        options: Vec<usize>,

    }

    fn fixture(items: &[&str]) -> Fixture {

        let styled = StyledDom::create_from_dom(ComboBox::new(sv(items)).dom());

        fn one(styled: &StyledDom, class: &str) -> usize {

            let found = nodes_with_class(styled, class);

            assert_eq!(found.len(), 1, "expected exactly one `{class}` node");

            found[0]

        }

        let wrapper = one(&styled, "__azul-native-combobox");

        let field = one(&styled, "__azul-native-combobox-input");

        // The class sits on the label `<p>`; the node the handlers re-text is

        // the bare text leaf inside it, which pre-order flattening puts next.

        let text_box = one(&styled, "__azul-native-combobox-text");

        let text = text_box + 1;

        assert!(

            matches!(styled.node_data.as_ref()[text].get_node_type(), NodeType::Text(_)),

            "the combobox field label must be `p > text`"

        );

        let list = one(&styled, "__azul-native-combobox-list");

        let options = nodes_with_class(&styled, "__azul-native-combobox-option");

        assert_eq!(options.len(), items.len());

        Fixture {

            styled,

            wrapper,

            field,

            text,

            list,

            options,

        }

    }

    /// A `DomNodeId` in the root DOM pointing at flattened node `idx`.

    fn node(idx: usize) -> DomNodeId {

        DomNodeId {

            dom: DomId::ROOT_ID,

            node: NodeHierarchyItemId::from_crate_internal(Some(NodeId::new(idx))),

        }

    }

    /// A `DomLayoutResult` with an *empty* layout tree: these handlers only walk

    /// `styled_dom.node_hierarchy`, so no real layout (and no font) is needed.

    fn layout_result(styled_dom: StyledDom) -> DomLayoutResult {

        DomLayoutResult {

            styled_dom,

            layout_tree: LayoutTree {

                nodes: Vec::new(),

                warm: Vec::new(),

                cold: Vec::new(),

                root: 0,

                dom_to_layout: BTreeMap::new(),

                children_arena: Vec::new(),

                children_offsets: Vec::new(),

                subtree_needs_intrinsic: Vec::new(),

            },

            calculated_positions: Vec::new(),

            viewport: LogicalRect::zero(),

            display_list: Arc::new(DisplayList::default()),

            scroll_ids: HashMap::new(),

            scroll_id_to_node_id: HashMap::new(),

        }

    }

    /// Everything the combobox handlers read out of the window: the styled DOM

    /// they navigate, the pending text changeset, and the pressed key.

    #[derive(Default)]

    struct Env {

        styled: Option<StyledDom>,

        changeset: Option<PendingTextEdit>,

        keycode: Option<VirtualKeyCode>,

    }

    /// Invokes `call` against a `LayoutWindow` built from `env`, with `hit` as the

    /// hit node. Returns the handler's value plus every recorded `CallbackChange`.

    fn run<R>(

        env: Env,

        hit: usize,

        data: RefAny,

        call: impl FnOnce(RefAny, CallbackInfo) -> R,

    ) -> (R, Vec<CallbackChange>) {

        let mut layout_window =

            LayoutWindow::new(FcFontCache::default()).expect("LayoutWindow::new failed");

        if let Some(sd) = env.styled {

            layout_window

                .layout_results

                .insert(DomId::ROOT_ID, layout_result(sd));

        }

        if let Some(changeset) = env.changeset {

            layout_window.text_input_manager.set_changeset(changeset);

        }

        let renderer_resources = RendererResources::default();

        let previous_window_state: Option<FullWindowState> = None;

        let mut current_window_state = FullWindowState::default();

        current_window_state.keyboard_state.current_virtual_keycode = env.keycode.into();

        let gl_context = OptionGlContextPtr::None;

        let scroll_states: BTreeMap<DomId, BTreeMap<NodeHierarchyItemId, ScrollPosition>> =

            BTreeMap::new();

        let window_handle = RawWindowHandle::Unsupported;

        let system_callbacks = ExternalSystemCallbacks::rust_internal();

        let ref_data = CallbackInfoRefData {

            layout_window: &layout_window,

            renderer_resources: &renderer_resources,

            previous_window_state: &previous_window_state,

            current_window_state: &current_window_state,

            gl_context: &gl_context,

            current_scroll_manager: &scroll_states,

            current_window_handle: &window_handle,

            system_callbacks: &system_callbacks,

            system_style: Arc::new(SystemStyle::default()),

            monitors: Arc::new(Mutex::new(MonitorVec::from_const_slice(&[]))),

            #[cfg(feature = "icu")]

            icu_localizer: IcuLocalizerHandle::default(),

            ctx: OptionRefAny::None,

        };

        let changes: Arc<Mutex<Vec<CallbackChange>>> = Arc::new(Mutex::new(Vec::new()));

        let info = CallbackInfo::new(

            &ref_data,

            &changes,

            node(hit),

            OptionLogicalPosition::None,

            OptionLogicalPosition::None,

        );

        let out = call(data, info);

        let recorded = core::mem::take(&mut *changes.lock().expect("change log poisoned"));

        (out, recorded)

    }

    /// Every `display` write in the change log, as `(node index, display)`.

    fn display_writes(changes: &[CallbackChange]) -> Vec<(usize, LayoutDisplay)> {

        let mut out = Vec::new();

        for change in changes {

            if let CallbackChange::ChangeNodeCssProperties {

                node_id, properties, ..

            } = change

            {

                for p in properties.as_ref() {

                    if let CssProperty::Display(v) = p {

                        if let Some(d) = v.get_property() {

                            out.push((node_id.index(), *d));

                        }

                    }

                }

            }

        }

        out

    }

    /// Every text write in the change log, as `(node index, new text)`.

    fn text_writes(changes: &[CallbackChange]) -> Vec<(usize, String)> {

        changes

            .iter()

            .filter_map(|change| match change {

                CallbackChange::ChangeNodeText { node_id, text } => Some((

                    node_id

                        .node

                        .into_crate_internal()

                        .expect("a text write always targets a real node")

                        .index(),

                    text.as_str().to_string(),

                )),

                _ => None,

            })

            .collect()

    }

    /// A `ComboBoxStateWrapper` payload with no user callback.

    fn state(items: &[&str], text: &str, open: bool, selected: usize) -> RefAny {

        RefAny::new(ComboBoxStateWrapper {

            inner: ComboBoxState {

                open,

                selected,

                text: AzString::from(text),

            },

            items: sv(items),

            on_select: None.into(),

        })

    }

    /// Reads the (still shared) `ComboBoxState` back out of a payload.

    fn inner_of(data: &mut RefAny) -> ComboBoxState {

        data.downcast_ref::<ComboBoxStateWrapper>()

            .expect("payload must still be a ComboBoxStateWrapper")

            .inner

            .clone()

    }

    fn on_select_cb(f: ComboBoxOnSelectCallbackType) -> ComboBoxOnSelectCallback {

        f.into()

    }

    /// Records every `ComboBoxState` a user `on_select` was handed.

    struct SelectLog {

        calls: Vec<ComboBoxState>,

    }

    extern "C" fn record_select(mut data: RefAny, _: CallbackInfo, s: ComboBoxState) -> Update {

        if let Some(mut log) = data.downcast_mut::<SelectLog>() {

            log.calls.push(s);

        }

        Update::RefreshDom

    }

    extern "C" fn select_do_nothing(_: RefAny, _: CallbackInfo, _: ComboBoxState) -> Update {

        Update::DoNothing

    }

    thread_local! {

        /// A clone of the shared state handle, smuggled into `probe_reborrow`

        /// without building a self-referential `RefAny` cycle.

        static SHARED_ALIAS: RefCell<Option<RefAny>> = const { RefCell::new(None) };

        /// `Some(true)` once `probe_reborrow` has seen the re-borrow refused.

        static REBORROW_REFUSED: Cell<Option<bool>> = const { Cell::new(None) };

    }

    extern "C" fn probe_reborrow(_: RefAny, _: CallbackInfo, _: ComboBoxState) -> Update {

        let refused = SHARED_ALIAS.with(|alias| {

            alias

                .borrow_mut()

                .as_mut()

                .expect("alias installed by the test")

                .downcast_mut::<ComboBoxStateWrapper>()

                .is_none()

        });

        REBORROW_REFUSED.with(|c| c.set(Some(refused)));

        Update::DoNothing

    }

    // ------------------------------------------------------------------

    // build_list_style

    // ------------------------------------------------------------------

    #[test]

    fn build_list_style_differs_only_in_display() {

        let closed = build_list_style(false);

        let open = build_list_style(true);

        let (c, o) = (closed.as_ref(), open.as_ref());

        assert!(!c.is_empty(), "the list style must not be empty");

        assert_eq!(

            c.len(),

            o.len(),

            "open and closed must declare the same property set so the runtime \

             `set_css_property(display)` toggle has everything it needs"

        );

        let differing: Vec<usize> = (0..c.len()).filter(|&i| c[i] != o[i]).collect();

        assert_eq!(

            differing.len(),

            1,

            "exactly one property may differ between open and closed"

        );

        assert!(matches!(

            &c[differing[0]].property,

            CssProperty::Display(_)

        ));

    }

    #[test]

    fn build_list_style_display_follows_the_flag() {

        assert_eq!(

            display_of(&build_list_style(false)),

            Some(LayoutDisplay::None),

            "a closed list is hidden"

        );

        assert_eq!(

            display_of(&build_list_style(true)),

            Some(LayoutDisplay::Block),

            "an open list is shown"

        );

    }

    #[test]

    fn build_list_style_always_positions_absolutely() {

        // Positioning must be present in BOTH states — the toggle only rewrites

        // `display`, so a missing `position` in the closed style would leave the

        // list statically positioned once opened.

        for open in [false, true] {

            let props = build_list_style(open);

            assert_eq!(

                position_of(&props),

                Some(LayoutPosition::Absolute),

                "open={open}"

            );

        }

    }

    #[test]

    fn build_list_style_is_deterministic_and_unshared() {

        // Two calls with the same flag must be equal, and neither may alias the

        // other (it allocates a fresh vec every call).

        assert_eq!(build_list_style(true), build_list_style(true));

        assert_eq!(build_list_style(false), build_list_style(false));

        assert_ne!(build_list_style(true), build_list_style(false));

    }

    // ------------------------------------------------------------------

    // ComboBox::new / create / Default

    // ------------------------------------------------------------------

    #[test]

    fn new_stores_items_and_starts_at_documented_defaults() {

        let combo = ComboBox::new(sv(&["a", "b", "c"]));

        assert_eq!(combo.combo_state.items.as_ref().len(), 3);

        assert_eq!(combo.combo_state.items.as_ref()[2].as_str(), "c");

        assert_eq!(combo.combo_state.inner, ComboBoxState::default());

        assert!(!combo.combo_state.inner.open, "the list starts closed");

        assert_eq!(combo.combo_state.inner.selected, 0);

        assert!(combo.combo_state.inner.text.as_str().is_empty());

        assert!(combo.placeholder.as_str().is_empty());

        assert!(

            combo.combo_state.on_select.is_none(),

            "ComboBox::new sets no callback"

        );

    }

    #[test]

    fn new_survives_extreme_item_lists() {

        let long = "ab".repeat(50_000);

        let cases: Vec<Vec<AzString>> = alloc::vec![

            Vec::new(),

            alloc::vec![AzString::from("")],

            alloc::vec![AzString::from("a\0b"), AzString::from("")],

            alloc::vec![AzString::from(

                "👨‍👩‍👧‍👦 e\u{0301}\u{0327} مرحبا שלום 🇩🇪"

            )],

            alloc::vec![AzString::from("\u{feff}\u{202e}rtl-override")],

            alloc::vec![AzString::from(long.as_str())],

        ];

        for items in cases {

            let combo = ComboBox::new(StringVec::from_vec(items.clone()));

            assert_eq!(combo.combo_state.items.as_ref(), items.as_slice());

            // ...and every option survives the trip through the DOM byte-for-byte

            let dom = combo.dom();

            let (_, list) = parts(&dom);

            assert_eq!(list.children.as_ref().len(), items.len());

            for (i, item) in items.iter().enumerate() {

                assert_eq!(text_of(&list.children.as_ref()[i]), Some(item.as_str()));

            }

        }

    }

    #[test]

    fn new_handles_many_duplicate_items() {

        // Duplicates are legal: selection is by index, not by label.

        let items = sv(&["same"; 512]);

        let combo = ComboBox::new(items);

        assert_eq!(combo.combo_state.items.as_ref().len(), 512);

        let dom = combo.dom();

        let (_, list) = parts(&dom);

        assert_eq!(list.children.as_ref().len(), 512);

    }

    #[test]

    fn create_is_empty_and_equals_default() {

        let combo = ComboBox::create();

        assert!(combo.combo_state.items.as_ref().is_empty());

        assert!(combo.combo_state.on_select.is_none());

        assert_eq!(combo.combo_state.inner, ComboBoxState::default());

        assert_eq!(combo, ComboBox::default());

        // repeated calls are independent, equal values

        assert_eq!(ComboBox::create(), ComboBox::create());

    }

    // ------------------------------------------------------------------

    // set_selected / with_selected  (numeric)

    // ------------------------------------------------------------------

    #[test]

    fn set_selected_stores_every_index_verbatim() {

        // The setter is documented as a plain store: no clamping to items.len(),

        // no saturation, no wrap — assert exactly that at both ends of usize.

        for value in [0usize, 1, 2, usize::MAX - 1, usize::MAX] {

            let mut combo = ComboBox::new(sv(&["a", "b"]));

            combo.set_selected(value);

            assert_eq!(combo.combo_state.inner.selected, value);

            // nothing else moved

            assert!(!combo.combo_state.inner.open);

            assert!(combo.combo_state.inner.text.as_str().is_empty());

            assert_eq!(combo.combo_state.items.as_ref().len(), 2);