//! Chip / tag widget — a compact rounded "pill" holding a short label plus an

//! optional removable "x" affordance. A blend of

//! [`crate::widgets::badge::Badge`] (the coloured pill visual + [`ChipKind`]

//! colour variants) and [`crate::widgets::alert::Alert`] (the dismiss pattern:

//! a stateful close affordance that hides the widget on click).

//!

//! When made removable (`with_removable(true)` or `set_on_remove`), the chip

//! mirrors the stateful pattern of [`crate::widgets::alert::Alert`]: it carries a

//! [`ChipStateWrapper`] (`{ visible } + on_remove`) in a [`RefAny`] attached to

//! the "x" node. Clicking "x" flips `visible` to `false`, invokes the optional

//! user `on_remove`, and hides the whole chip by setting `display: none` on the

//! container via `set_css_property` (mirroring alert's live restyle). A

//! non-removable chip renders no "x" and carries no live callback — it is then

//! just a stateless styled pill (a near-clone of [`Badge`]).

//!

//! Key types: [`Chip`], [`ChipKind`], [`ChipState`], [`ChipOnRemove`],

//! [`ChipOnClick`].

use azul_core::{

    callbacks::{CoreCallbackData, Update},

    dom::{Dom, IdOrClass, IdOrClass::Class, IdOrClassVec, TabIndex},

    refany::RefAny,

};

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

use azul_css::{

    props::{

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

        layout::{LayoutDisplay, LayoutFlexDirection, LayoutAlignItems, LayoutAlignSelf, LayoutFlexGrow, LayoutPaddingTop, LayoutPaddingBottom, LayoutPaddingLeft, LayoutPaddingRight, LayoutMarginLeft},

        property::{CssProperty, *},

        style::{StyleBackgroundContentVec, StyleBackgroundContent, StyleBorderTopLeftRadius, StyleBorderTopRightRadius, StyleBorderBottomLeftRadius, StyleBorderBottomRightRadius, StyleTextColor, StyleTextAlign, StyleUserSelect, StyleCursor},

    },

    impl_option_inner, AzString,

};

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

static CHIP_CONTAINER_CLASS: &[IdOrClass] = &[Class(AzString::from_const_str("__azul-native-chip"))];

static CHIP_LABEL_CLASS: &[IdOrClass] =

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

static CHIP_REMOVE_CLASS: &[IdOrClass] =

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

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);

/// Callback function type invoked when a removable chip's "x" is clicked.

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

impl_widget_callback!(

    ChipOnRemove,

    OptionChipOnRemove,

    ChipOnRemoveCallback,

    ChipOnRemoveCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        ChipOnRemoveCallback,

    info_ty:        CallbackInfo,

    return_ty:      Update,

    default_ret:    Update::DoNothing,

    invoker_static: CHIP_ON_REMOVE_INVOKER,

    invoker_ty:     AzChipOnRemoveCallbackInvoker,

    thunk_fn:       az_chip_on_remove_callback_thunk,

    setter_fn:      AzApp_setChipOnRemoveCallbackInvoker,

    from_handle_fn: AzChipOnRemoveCallback_createFromHostHandle,

    extra_args:     [ state: ChipState ],

}

/// Callback function type invoked when the chip's label area is clicked.

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

impl_widget_callback!(

    ChipOnClick,

    OptionChipOnClick,

    ChipOnClickCallback,

    ChipOnClickCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        ChipOnClickCallback,

    info_ty:        CallbackInfo,

    return_ty:      Update,

    default_ret:    Update::DoNothing,

    invoker_static: CHIP_ON_CLICK_INVOKER,

    invoker_ty:     AzChipOnClickCallbackInvoker,

    thunk_fn:       az_chip_on_click_callback_thunk,

    setter_fn:      AzApp_setChipOnClickCallbackInvoker,

    from_handle_fn: AzChipOnClickCallback_createFromHostHandle,

    extra_args:     [ state: ChipState ],

}

/// The semantic colour variant of a [`Chip`] (mirrors `badge::BadgeKind`).

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

#[repr(C)]

pub enum ChipKind {

    /// Neutral light-grey chip — the default.

    #[default]

    Default,

    /// Blue "primary" chip.

    Primary,

    /// Green "success" chip.

    Success,

    /// Red "danger" chip.

    Danger,

    /// Yellow "warning" chip (uses dark text).

    Warning,

    /// Cyan "info" chip (uses dark text).

    Info,

}

impl ChipKind {

    /// Returns the `(background, text)` colours for this chip kind.

    #[allow(clippy::trivially_copy_pass_by_ref)] // <=8B Copy param kept by-ref intentionally (hot pixel/coord path or to avoid churning call sites for a perf-neutral change)

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

        const DARK: ColorU = ColorU { r: 33, g: 37, b: 41, a: 255 };

            // The default chip is a light neutral pill with dark text (the

            // common "tag" look), unlike Badge's solid grey.

        }

    /// CSS class name for this chip kind (mirrors `BadgeKind::class_name`).

        }

}

/// A compact rounded pill holding a label plus an optional removable "x".

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

#[repr(C)]

pub struct Chip {

    /// Runtime state (`visible`) plus the optional remove callback.

    pub chip_state: ChipStateWrapper,

    /// The text shown inside the pill.

    pub label: AzString,

    /// The colour variant.

    pub kind: ChipKind,

    /// Whether to render the "x" remove affordance (hides the chip on click).

    pub removable: bool,

    /// The computed inline style for the pill container.

    pub container_style: CssPropertyWithConditionsVec,

}

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

#[repr(C)]

pub struct ChipStateWrapper {

    /// Whether the chip is currently visible.

    pub inner: ChipState,

    /// Optional: function to call when the chip is removed.

    pub on_remove: OptionChipOnRemove,

    /// Optional: function to call when the chip's label area is clicked.

    pub on_click: OptionChipOnClick,

}

/// The visible/hidden state of a [`Chip`].

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

#[repr(C)]

pub struct ChipState {

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

    pub visible: bool,

}

impl Default for ChipState {

}

/// Builds the pill container style for a given [`ChipKind`]. The colours are the

/// only kind-dependent properties, so the style is built at runtime per the

/// recipe's "runtime vec when param-dependent" path (see `badge::build_badge_style`).

        )),

        // Hug the content rather than stretch across a flex parent's cross axis.

            0,

        ))),

        // padding: 4px 10px

            4,

        ))),

        )),

        )),

        )),

        // border-radius: 12px (pill)

        )),

        )),

        )),

        )),

        // Text colour is inherited by the label + "x" children.

    ])

/// Label style: left-aligned, hugs its content.

static CHIP_LABEL_STYLE: &[CssPropertyWithConditions] = &[

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

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

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

];

/// "x" remove-affordance style: a small pointer-cursor box on the right.

static CHIP_REMOVE_STYLE: &[CssPropertyWithConditions] = &[

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

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

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

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

    CssPropertyWithConditions::simple(CssProperty::const_margin_left(LayoutMarginLeft::const_px(

        6,

    ))),

];

impl Chip {

    /// Creates a new chip with the given label and the default (light-grey) kind.

    #[inline]

    /// Creates a new chip with the given label and colour variant.

    #[inline]

    /// Sets the colour variant, recomputing the container style.

    #[inline]

    /// Builder-style setter for the colour variant.

    #[inline]

    /// Sets whether the chip shows a "x" remove affordance.

    #[inline]

    /// Builder-style setter for the removable flag.

    #[inline]

    /// Sets the remove callback. Implies `removable = true` so the "x" is rendered.

    #[inline]

    /// Builder-style setter for the remove callback (implies removable).

    #[inline]

    /// Sets the click callback, invoked when the chip's label area is clicked.

    #[inline]

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

    #[inline]

    /// Replaces `self` with an empty default chip and returns the original.

    #[inline]

    /// Converts this chip into a DOM subtree with the `__azul-native-chip` class.

    #[inline]

        use azul_core::{

            callbacks::CoreCallback,

            dom::{EventFilter, HoverEventFilter},

            refany::OptionRefAny,

        };

        // The remove ("x") and the label-click callbacks share the same state

        // RefAny so both handlers observe the same ChipState.

        // The click callback is attached to the LABEL node rather than the

        // pill container: a container-level MouseUp would also fire when the

        // remove "x" (a child of the container) is clicked, double-firing

        // alongside on_remove. Attaching per-child sidesteps that (same

        // wiring as list_view's row/column callbacks); clicks on the pill's

        // padding therefore do not trigger on_click.

}

impl Default for Chip {

}

/// "x" click handler. The hit node is the "x" (the callback-bearing node, per

/// `currentTarget` semantics — see `radio_group`); its parent is the chip

/// container. Flips `visible` to `false`, invokes the optional user callback,

/// then hides the whole chip via `display: none`.

    };

        };

        }

    };

    // TODO2: hides the chip by toggling `display: none` via set_css_property.

    // This follows the proven live-restyle pattern of alert/check_box/radio_group

    // (which toggle display/opacity/background); the display:none relayout itself

    // is not GUI-verified in this build.

/// Label click handler. Invokes the optional user `on_click` with the current

/// [`ChipState`] (mirrors `default_on_chip_remove`, minus the state flip/hide).

    };

    }

impl From<Chip> for Dom {

}

#[cfg(test)]

mod autotest_generated {

    use std::{

        collections::{BTreeMap, HashMap, HashSet},

        sync::{Arc, Mutex},

    };

    use azul_core::{

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

        geom::{LogicalRect, OptionLogicalPosition},

        gl::OptionGlContextPtr,

        hit_test::ScrollPosition,

        refany::OptionRefAny,

        resources::RendererResources,

        styled_dom::{NodeHierarchyItemId, StyledDom},

        window::{MonitorVec, RawWindowHandle},

    };

    use azul_css::{

        props::basic::{length::SizeMetric, pixel::PixelValue},

        system::SystemStyle,

    };

    use rust_fontconfig::FcFontCache;

    use super::*;

    #[cfg(feature = "icu")]

    use crate::icu::IcuLocalizerHandle;

    use crate::{

        callbacks::{CallbackChange, CallbackInfoRefData, ExternalSystemCallbacks},

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

        window::{DomLayoutResult, LayoutWindow},

        window_state::FullWindowState,

    };

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

    // Helpers

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

    /// Every variant of `ChipKind` — the complete input domain of `colors`,

    /// `class_name` and `build_chip_style`.

    const ALL_KINDS: [ChipKind; 6] = [

        ChipKind::Default,

        ChipKind::Primary,

        ChipKind::Success,

        ChipKind::Danger,

        ChipKind::Warning,

        ChipKind::Info,

    ];

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

    const DARK: ColorU = ColorU { r: 33, g: 37, b: 41, a: 255 };

    /// The declared properties of a style vec, in declaration order.

    fn properties(v: &CssPropertyWithConditionsVec) -> Vec<CssProperty> {

        v.as_ref().iter().map(|p| p.property.clone()).collect()

    }

    /// The *kind* of every declared property, in order (ignores the values).

    fn property_types(

        v: &CssPropertyWithConditionsVec,

    ) -> Vec<core::mem::Discriminant<CssProperty>> {

        v.as_ref().iter().map(|p| core::mem::discriminant(&p.property)).collect()

    }

    /// The `f32` of a `PixelValue`, asserting it is an absolute `px` length — an

    /// `em`/`%` slipping into the pill geometry would resolve against the parent

    /// font/box instead of the intended fixed padding or radius.

    fn px(pv: &PixelValue) -> f32 {

        assert_eq!(pv.metric, SizeMetric::Px, "chip geometry must be absolute px, got {:?}", pv.metric);

        pv.number.get()

    }

    /// The four paddings in `(top, bottom, left, right)` order.

    fn padding_px(

        v: &CssPropertyWithConditionsVec,

    ) -> (Option<f32>, Option<f32>, Option<f32>, Option<f32>) {

        let find = |f: &dyn Fn(&CssProperty) -> Option<f32>| v.as_ref().iter().find_map(|p| f(&p.property));

        (

            find(&|p| match p {

                CssProperty::PaddingTop(x) => x.get_property().map(|x| px(&x.inner)),

                _ => None,

            }),

            find(&|p| match p {

                CssProperty::PaddingBottom(x) => x.get_property().map(|x| px(&x.inner)),

                _ => None,

            }),

            find(&|p| match p {

                CssProperty::PaddingLeft(x) => x.get_property().map(|x| px(&x.inner)),

                _ => None,

            }),

            find(&|p| match p {

                CssProperty::PaddingRight(x) => x.get_property().map(|x| px(&x.inner)),

                _ => None,

            }),

        )

    }

    /// The four corner radii, in declaration order.

    fn radii_px(v: &CssPropertyWithConditionsVec) -> Vec<f32> {

        v.as_ref()

            .iter()

            .filter_map(|p| match &p.property {

                CssProperty::BorderTopLeftRadius(r) => r.get_property().map(|r| px(&r.inner)),

                CssProperty::BorderTopRightRadius(r) => r.get_property().map(|r| px(&r.inner)),

                CssProperty::BorderBottomLeftRadius(r) => r.get_property().map(|r| px(&r.inner)),

                CssProperty::BorderBottomRightRadius(r) => r.get_property().map(|r| px(&r.inner)),

                _ => None,

            })

            .collect()

    }

    fn font_size_px(v: &CssPropertyWithConditionsVec) -> Option<f32> {

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

            CssProperty::FontSize(f) => f.get_property().map(|f| px(&f.inner)),

            _ => None,

        })

    }

    fn text_color(v: &CssPropertyWithConditionsVec) -> Option<ColorU> {

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

            CssProperty::TextColor(c) => c.get_property().map(|c| c.inner),

            _ => None,

        })

    }

    /// The single background layer of a style vec, asserting there is exactly one

    /// and that it is a flat colour (a gradient would not be a `Color`).

    fn background_color(v: &CssPropertyWithConditionsVec) -> Option<ColorU> {

        let bg = v.as_ref().iter().find_map(|p| match &p.property {

            CssProperty::BackgroundContent(b) => b.get_property(),

            _ => None,

        })?;

        assert_eq!(bg.as_ref().len(), 1, "a chip must declare exactly one background layer");

        match &bg.as_ref()[0] {

            StyleBackgroundContent::Color(c) => Some(*c),

            other => panic!("chip background is not a flat colour: {other:?}"),

        }

    }

    /// Every `PixelValue` a style vec mentions (paddings, radii, font size).

    fn all_pixel_values(v: &CssPropertyWithConditionsVec) -> Vec<PixelValue> {

        v.as_ref()

            .iter()

            .filter_map(|p| match &p.property {

                CssProperty::PaddingTop(x) => x.get_property().map(|x| x.inner),

                CssProperty::PaddingBottom(x) => x.get_property().map(|x| x.inner),

                CssProperty::PaddingLeft(x) => x.get_property().map(|x| x.inner),

                CssProperty::PaddingRight(x) => x.get_property().map(|x| x.inner),

                CssProperty::BorderTopLeftRadius(r) => r.get_property().map(|r| r.inner),

                CssProperty::BorderTopRightRadius(r) => r.get_property().map(|r| r.inner),

                CssProperty::BorderBottomLeftRadius(r) => r.get_property().map(|r| r.inner),

                CssProperty::BorderBottomRightRadius(r) => r.get_property().map(|r| r.inner),

                CssProperty::FontSize(f) => f.get_property().map(|f| f.inner),

                _ => None,

            })

            .collect()

    }

    /// Perceived brightness (0..=255) of an sRGB colour, Rec.709 weights. Kept to

    /// plain `+`/`*` (no gamma expansion) so the readability assertions below stay

    /// exact and toolchain-independent.

    fn luma(c: ColorU) -> f32 {

        0.2126 * f32::from(c.r) + 0.7152 * f32::from(c.g) + 0.0722 * f32::from(c.b)

    }

    /// 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 properties of a rendered node's *inline* style, in declaration order.

    fn inline_properties(node: &Dom) -> Vec<CssProperty> {

        node.root.style.iter_inline_properties().map(|(p, _)| p.clone()).collect()

    }

    /// Adversarial chip labels: empty, whitespace, combining marks, ZWJ emoji,

    /// RTL, embedded NULs (`AzString` is length-based, so a NUL must not

    /// truncate), the remove glyph itself, and a string far longer than any

    /// plausible tag.

    fn adversarial_strings() -> Vec<String> {

        let mut v: Vec<String> = [

            "",

            "tag",

            " ",

            "e\u{0301}",                                   // e + combining acute

            "\u{1F469}\u{200D}\u{1F469}\u{200D}\u{1F467}", // ZWJ family emoji

            "\u{5E9}\u{5DC}\u{5D5}\u{5DD}",                // RTL Hebrew

            "\0",                                          // a single NUL

            "a\0b",                                        // embedded NUL

            "\u{FFFD}\u{202E}\u{200B}",                    // replacement char, RTL override, ZWSP

            "\u{00D7}",                                    // the remove glyph as a label

            "line\nbreak\ttab",                            // control characters

            "-9223372036854775808",                        // i64::MIN as a "count"

        ]

        .iter()

        .map(|s| (*s).to_string())

        .collect();

        v.push("x".repeat(100_000));

        v

    }

    fn remove_cb(f: ChipOnRemoveCallbackType) -> ChipOnRemoveCallback {

        f.into()

    }

    fn click_cb(f: ChipOnClickCallbackType) -> ChipOnClickCallback {

        f.into()

    }

    /// A `RefAny` payload recording every `ChipState` a user callback observes.

    struct StateLog {

        calls: Vec<bool>,

    }

    extern "C" fn record_remove(mut data: RefAny, _: CallbackInfo, state: ChipState) -> Update {

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

            log.calls.push(state.visible);

        }

        Update::RefreshDom

    }

    extern "C" fn record_click(mut data: RefAny, _: CallbackInfo, state: ChipState) -> Update {

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

            log.calls.push(state.visible);

            log.calls.push(state.visible); // keeps this body distinct from record_remove

        }

        Update::RefreshDom

    }

    extern "C" fn remove_do_nothing(_: RefAny, _: CallbackInfo, _: ChipState) -> Update {

        Update::DoNothing

    }

    extern "C" fn click_do_nothing(_: RefAny, _: CallbackInfo, state: ChipState) -> Update {

        // `state.visible` is read (and discarded) purely so this body cannot be

        // identical-code-folded onto `remove_do_nothing`; the tests below compare

        // callback function pointers for inequality.

        let _ = state.visible;

        Update::DoNothing

    }

    /// A payload whose callback tries to read the *same* `ChipStateWrapper`

    /// `RefAny` that the handler is currently holding a mutable borrow on.

    struct ReentrantProbe {

        /// A clone of the state `RefAny` the handler was invoked with.

        state: RefAny,

        /// `Some(visible)` if the re-entrant read succeeded, `None` if it was

        /// refused. Starts as `Some(true)` so "never ran" is distinguishable.

        saw_state: Option<bool>,

        calls: usize,

    }

    extern "C" fn probe_state_reentrantly(

        mut data: RefAny,

        _: CallbackInfo,

        _: ChipState,

    ) -> Update {

        if let Some(mut probe) = data.downcast_mut::<ReentrantProbe>() {

            probe.calls += 1;

            let mut state = probe.state.clone();

            probe.saw_state = state.downcast_ref::<ChipStateWrapper>().map(|w| w.inner.visible);

        }

        Update::DoNothing

    }

    /// `visible` of a `ChipStateWrapper` payload.

    fn wrapper_visible(data: &mut RefAny) -> bool {

        data.downcast_ref::<ChipStateWrapper>()

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

            .inner

            .visible

    }

    /// The `visible` flags recorded by a `StateLog` payload.

    fn log_calls(data: &mut RefAny) -> Vec<bool> {

        data.downcast_ref::<StateLog>()

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

            .calls

            .clone()

    }

    /// A `DomLayoutResult` with an *empty* layout tree: the chip 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(),

        }

    }

    /// Flat indices of a removable chip in depth-first pre-order:

    /// `0 container / 1 label <p> / 2 label text / 3 remove <p> / 4 remove text`.

    /// Both callbacks sit on the `<p>`s — a text node owns no rect and could

    /// never be hit-tested.

    const LABEL_NODE: usize = 1;

    const REMOVE_NODE: usize = 3;

    /// The flattened DOM of a removable chip — exactly the hierarchy

    /// `default_on_chip_remove` walks (hit node -> parent).

    fn removable_styled_dom() -> StyledDom {

        let chip = Chip::create(AzString::from("tag")).with_removable(true);

        let styled = StyledDom::create_from_dom(chip.dom());

        assert_eq!(

            styled.node_hierarchy.as_ref().len(),

            5,

            "fixture must flatten to container / label <p> + text / remove <p> + text"

        );

        styled

    }

    /// Builds a `CallbackInfo` pointing at node `hit` of `styled` (or at a window

    /// with no layout result at all when `styled` is `None`), hands it to `f`, and

    /// returns `f`'s result plus every recorded `CallbackChange`.

    fn with_callback_info<R>(

        styled: Option<StyledDom>,

        hit: usize,

        f: impl FnOnce(CallbackInfo) -> R,

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

        let mut layout_window =

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

        if let Some(sd) = styled {

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

        }

        let renderer_resources = RendererResources::default();

        let previous_window_state: Option<FullWindowState> = None;

        let current_window_state = FullWindowState::default();

        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,

            DomNodeId {

                dom: DomId::ROOT_ID,

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

            },

            OptionLogicalPosition::None,

            OptionLogicalPosition::None,

        );

        let out = f(info);

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

        (out, recorded)

    }

    fn run_remove(

        styled: Option<StyledDom>,

        hit: usize,

        data: RefAny,

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

        with_callback_info(styled, hit, move |info| default_on_chip_remove(data, info))

    }

    fn run_click(

        styled: Option<StyledDom>,

        hit: usize,

        data: RefAny,

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

        with_callback_info(styled, hit, move |info| default_on_chip_click(data, info))

    }

    /// Every `display` write recorded 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

    }

    /// A `ChipStateWrapper` wired to `record_remove`, plus the log it writes to.

    fn state_with_remove_log() -> (RefAny, RefAny) {

        let log = RefAny::new(StateLog { calls: Vec::new() });

        let state = RefAny::new(ChipStateWrapper {

            inner: ChipState { visible: true },

            on_remove: Some(ChipOnRemove {

                callback: remove_cb(record_remove),

                refany: log.clone(),

            })

            .into(),

            on_click: OptionChipOnClick::None,

        });

        (state, log)

    }

    /// A `ChipStateWrapper` wired to `record_click`, plus the log it writes to.

    fn state_with_click_log(visible: bool) -> (RefAny, RefAny) {

        let log = RefAny::new(StateLog { calls: Vec::new() });

        let state = RefAny::new(ChipStateWrapper {

            inner: ChipState { visible },

            on_remove: OptionChipOnRemove::None,

            on_click: Some(ChipOnClick { callback: click_cb(record_click), refany: log.clone() })

                .into(),

        });

        (state, log)

    }

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

    // ChipKind::colors  (getter)

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

    #[test]

    fn colors_returns_the_documented_constants_for_every_kind() {

        let expected = [

            // NOTE: unlike `BadgeKind::Default` (solid grey + white text), the

            // default *chip* is the light neutral "tag" pill with dark text.

            (ChipKind::Default, ColorU { r: 233, g: 236, b: 239, a: 255 }, DARK),

            (ChipKind::Primary, ColorU { r: 13, g: 110, b: 253, a: 255 }, WHITE),

            (ChipKind::Success, ColorU { r: 25, g: 135, b: 84, a: 255 }, WHITE),

            (ChipKind::Danger, ColorU { r: 220, g: 53, b: 69, a: 255 }, WHITE),

            (ChipKind::Warning, ColorU { r: 255, g: 193, b: 7, a: 255 }, DARK),

            (ChipKind::Info, ColorU { r: 13, g: 202, b: 240, a: 255 }, DARK),

        ];

        for (kind, bg, text) in expected {

            assert_eq!(kind.colors(), (bg, text), "{kind:?}: wrong (background, text) pair");

        }

        // The doc comments promise Default/Warning/Info are the dark-text kinds and

        // no others: a fourth dark-text kind sneaking in here is a regression.

        for kind in ALL_KINDS {

            let (_, text) = kind.colors();

            let dark_text = matches!(kind, ChipKind::Default | ChipKind::Warning | ChipKind::Info);

            assert_eq!(

                text == DARK,

                dark_text,

                "{kind:?}: text colour contradicts the documented variant"

            );

        }

    }

    #[test]

    fn colors_only_ever_returns_one_of_the_two_documented_text_colours() {

        for kind in ALL_KINDS {

            let (_, text) = kind.colors();

            assert!(

                text == WHITE || text == DARK,

                "{kind:?}: text colour {text:?} is neither the documented WHITE nor DARK"

            );

        }

    }

    #[test]

    fn colors_are_fully_opaque_on_every_kind() {

        // A non-opaque pill would let the page background bleed through and

        // silently destroy the contrast the kind was chosen for.

        for kind in ALL_KINDS {

            let (bg, text) = kind.colors();

            assert_eq!(bg.a, 255, "{kind:?}: translucent background {bg:?}");

            assert_eq!(text.a, 255, "{kind:?}: translucent text colour {text:?}");

            assert_ne!(bg, text, "{kind:?}: an invisible label is not a chip");

        }

    }

    #[test]

    fn colors_give_every_kind_a_distinguishable_background() {

        // Two kinds that render identically make the semantic variant useless.

        let mut seen = HashSet::new();

        for kind in ALL_KINDS {

            let (bg, _) = kind.colors();

            assert!(

                seen.insert((bg.r, bg.g, bg.b, bg.a)),

                "{kind:?}: duplicate background colour {bg:?}"

            );

        }

        assert_eq!(seen.len(), ALL_KINDS.len());

    }

    #[test]

    fn colors_pick_the_more_readable_of_the_two_text_colours() {

        // The only real invariant of `colors()`: the text must be legible on the

        // pill. For each kind the chosen text colour must be further from the

        // background (in perceived brightness) than the rejected alternative,

        // and light backgrounds must take the dark text.

        for kind in ALL_KINDS {

            let (bg, text) = kind.colors();

            let other = if text == WHITE { DARK } else { WHITE };

            let chosen = (luma(bg) - luma(text)).abs();

            let rejected = (luma(bg) - luma(other)).abs();

            assert!(

                chosen > rejected,

                "{kind:?}: text {text:?} (delta luma {chosen:.1}) is less readable on {bg:?} than \

                 {other:?} (delta luma {rejected:.1})"

            );

            assert!(chosen >= 60.0, "{kind:?}: text/background brightness gap {chosen:.1} is too low to read");

            // Mid-grey split: a light pill must not carry white text.

            let light_bg = luma(bg) >= 128.0;

            assert_eq!(text == DARK, light_bg, "{kind:?}: bg luma {:.1} but text is {text:?}", luma(bg));

        }

    }

    #[test]

    fn colors_is_pure_and_the_default_kind_is_the_neutral_tag() {

        assert_eq!(ChipKind::default(), ChipKind::Default);

        assert_eq!(ChipKind::default().colors(), ChipKind::Default.colors());

        // `colors()` takes `&self` on a `Copy` enum: repeated calls, and calls

        // through a copy, must be side-effect free and identical.

        for kind in ALL_KINDS {

            let copy = kind;

            assert_eq!(kind.colors(), kind.colors(), "{kind:?}: colors() is not pure");

            assert_eq!(kind.colors(), copy.colors(), "{kind:?}: a copy disagrees with the original");

        }

    }

    #[test]

    fn colors_is_const_evaluable() {

        const DEFAULT: (ColorU, ColorU) = ChipKind::Default.colors();

        assert_eq!(DEFAULT.0, ColorU { r: 233, g: 236, b: 239, a: 255 });

        assert_eq!(DEFAULT.1, DARK);

    }

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

    // ChipKind::class_name  (getter)

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

    #[test]

    fn class_name_returns_the_documented_string_for_every_kind() {

        assert_eq!(ChipKind::Default.class_name(), "__azul-chip-default");

        assert_eq!(ChipKind::Primary.class_name(), "__azul-chip-primary");

        assert_eq!(ChipKind::Success.class_name(), "__azul-chip-success");

        assert_eq!(ChipKind::Danger.class_name(), "__azul-chip-danger");

        assert_eq!(ChipKind::Warning.class_name(), "__azul-chip-warning");

        assert_eq!(ChipKind::Info.class_name(), "__azul-chip-info");

        assert_eq!(ChipKind::default().class_name(), "__azul-chip-default");

    }

    #[test]

    fn class_name_is_unique_per_kind_and_a_usable_css_identifier() {

        let mut seen = HashSet::new();

        for kind in ALL_KINDS {

            let name = kind.class_name();

            assert!(seen.insert(name), "{kind:?}: class name {name:?} collides with another kind");

            assert!(!name.is_empty(), "{kind:?}: empty class name");

            assert!(name.starts_with("__azul-chip-"), "{kind:?}: unnamespaced class {name:?}");

            assert!(name.is_ascii(), "{kind:?}: non-ASCII class name {name:?}");

            // A space, a dot or a `#` would silently split/re-target the selector.

            assert!(

                name.chars().all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_'),

                "{kind:?}: class name {name:?} contains a CSS-significant character"

            );

            // The returned `&'static str` must be stable across calls.

            assert_eq!(

                name.as_ptr(),

                kind.class_name().as_ptr(),

                "{kind:?}: class_name() is not a stable constant"

            );

        }

        assert_eq!(seen.len(), ALL_KINDS.len());

    }

    #[test]

    fn class_name_does_not_collide_with_the_widget_element_classes() {

        // `__azul-native-chip` is a *prefix* of `__azul-native-chip-label` and

        // `__azul-native-chip-remove`; the kind classes live in their own

        // `__azul-chip-` namespace and must not alias any of the three.

        let element_classes =

            ["__azul-native-chip", "__azul-native-chip-label", "__azul-native-chip-remove"];

        for kind in ALL_KINDS {

            let name = kind.class_name();

            for element in element_classes {

                assert_ne!(name, element, "{kind:?}: kind class shadows the element class {element:?}");

            }

        }

    }

    #[test]

    fn class_name_is_const_evaluable() {

        const DANGER: &str = ChipKind::Danger.class_name();

        assert_eq!(DANGER, "__azul-chip-danger");

    }

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

    // build_chip_style

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

    #[test]

    fn build_chip_style_emits_the_documented_pill_geometry() {

        for kind in ALL_KINDS {

            let style = build_chip_style(kind);

            assert_eq!(

                padding_px(&style),

                (Some(4.0), Some(4.0), Some(10.0), Some(10.0)),

                "{kind:?}: padding is not 4px 10px"

            );

            assert_eq!(

                radii_px(&style),

                vec![12.0, 12.0, 12.0, 12.0],

                "{kind:?}: all four corners must carry a 12px radius"

            );

            assert_eq!(font_size_px(&style), Some(13.0), "{kind:?}: wrong font size");

        }

    }

    #[test]

    fn build_chip_style_radius_actually_rounds_the_chip_to_a_pill() {

        // The widget's premise: the corner radius must reach at least half the

        // content height (font + vertical padding), otherwise it renders as a

        // rounded rectangle rather than a pill.

        for kind in ALL_KINDS {

            let style = build_chip_style(kind);

            let (top, bottom, ..) = padding_px(&style);

            let height = font_size_px(&style).expect("a font size must be declared")

                + top.expect("padding-top")

                + bottom.expect("padding-bottom");

            for r in radii_px(&style) {

                assert!(

                    r * 2.0 >= height,

                    "{kind:?}: radius {r} does not reach half of the {height}px pill height"

                );

            }

        }

    }

    #[test]

    fn build_chip_style_is_a_row_flexbox_that_hugs_its_content() {

        for kind in ALL_KINDS {

            let props = properties(&build_chip_style(kind));

            let has = |p: &CssProperty| props.contains(p);

            assert!(has(&CssProperty::const_display(LayoutDisplay::Flex)), "{kind:?}: not a flex box");

            assert!(

                has(&CssProperty::const_flex_direction(LayoutFlexDirection::Row)),

                "{kind:?}: the label and the x must sit side by side"

            );

            assert!(

                has(&CssProperty::const_align_items(LayoutAlignItems::Center)),

                "{kind:?}: label and x not vertically centred"

            );

            // align-self: start + flex-grow: 0 — without both, the pill stretches

            // across a flex parent instead of hugging its label.

            assert!(

                has(&CssProperty::align_self(LayoutAlignSelf::Start)),

                "{kind:?}: chip stretches on the cross axis"

            );

            assert!(

                has(&CssProperty::const_flex_grow(LayoutFlexGrow::const_new(0))),

                "{kind:?}: chip grows on the main axis"

            );

        }

    }

    #[test]

    fn build_chip_style_leaves_text_alignment_to_the_label() {

        // Unlike `badge`, the chip container declares neither `text-align` nor

        // `justify-content` — the label child owns `text-align: left`. A

        // container-level declaration here would fight the label's own style.

        for kind in ALL_KINDS {

            for p in build_chip_style(kind).as_ref() {

                assert!(

                    !matches!(p.property, CssProperty::TextAlign(_)),

                    "{kind:?}: the container must not declare text-align"

                );

                assert!(

                    !matches!(p.property, CssProperty::JustifyContent(_)),

                    "{kind:?}: the container must not declare justify-content"

                );

            }

        }

    }

    #[test]

    fn build_chip_style_declares_the_inheritable_text_style_once() {

        // The label and the "x" carry no colour/family of their own — both are

        // inherited from the container, so the container must declare them.

        for kind in ALL_KINDS {

            let style = build_chip_style(kind);

            let families: Vec<_> = style

                .as_ref()

                .iter()

                .filter_map(|p| match &p.property {

                    CssProperty::FontFamily(f) => f.get_property(),

                    _ => None,

                })

                .collect();

            assert_eq!(families.len(), 1, "{kind:?}: exactly one font-family declaration");

            let fams = families[0].as_ref();

            assert_eq!(fams.len(), 1, "{kind:?}: expected a single system-ui family");

            match &fams[0] {

                StyleFontFamily::System(name) => {

                    assert_eq!(name.as_str(), "system:ui", "{kind:?}: wrong system font family")

                }

                other => panic!("{kind:?}: chip must use the system UI font, got {other:?}"),

            }

            assert!(text_color(&style).is_some(), "{kind:?}: no inheritable text colour declared");

        }

    }

    #[test]

    fn build_chip_style_colours_track_the_kind() {

        for kind in ALL_KINDS {

            let style = build_chip_style(kind);

            let (bg, text) = kind.colors();

            assert_eq!(background_color(&style), Some(bg), "{kind:?}: emitted background != colors().0");

            assert_eq!(text_color(&style), Some(text), "{kind:?}: emitted text colour != colors().1");

        }

    }

    #[test]

    fn build_chip_style_declares_every_property_at_most_once() {

        // A duplicated declaration is a last-one-wins ambiguity: two backgrounds

        // would make one of them silently dead.

        for kind in ALL_KINDS {

            let types = property_types(&build_chip_style(kind));

            let mut seen = HashSet::new();

            for t in &types {

                assert!(seen.insert(*t), "{kind:?}: the container style declares the same property twice");

            }

            assert_eq!(seen.len(), types.len());

        }

    }

    #[test]

    fn build_chip_style_properties_are_all_unconditional() {

        // The chip container is stateless — a declaration gated on

        // `:hover`/`:active` would simply never paint.

        for kind in ALL_KINDS {

            for p in build_chip_style(kind).as_ref() {

                assert!(

                    p.apply_if.as_ref().is_empty(),

                    "{kind:?}: {:?} is conditional on a stateless container",

                    p.property

                );

            }

        }

    }

    #[test]

    fn build_chip_style_is_deterministic_and_kind_dependent() {

        let baseline = property_types(&build_chip_style(ChipKind::Default));

        assert!(!baseline.is_empty(), "the container style must not be empty");

        for kind in ALL_KINDS {

            assert_eq!(

                properties(&build_chip_style(kind)),

                properties(&build_chip_style(kind)),

                "{kind:?}: two builds of the same kind disagree"

            );

            assert_eq!(

                property_types(&build_chip_style(kind)),

                baseline,

                "{kind:?}: declares different properties, or in a different order, than Default"

            );

        }

        // No two kinds may collapse onto the same style, or the variant is a no-op.

        for (i, a) in ALL_KINDS.iter().enumerate() {

            for b in &ALL_KINDS[i + 1..] {

                assert_ne!(

                    properties(&build_chip_style(*a)),

                    properties(&build_chip_style(*b)),

                    "{a:?} and {b:?} produce an identical style"

                );

            }

        }

    }

    #[test]

    fn build_chip_style_differs_only_in_the_colours() {

        // Exactly two declarations may depend on the kind: the background and the

        // text colour. Kinds that share a text colour (Default/Warning/Info are

        // all dark-on-light) must therefore differ in the background *alone* —

        // any third differing declaration means geometry leaked into the palette.

        for (i, a) in ALL_KINDS.iter().enumerate() {

            for b in &ALL_KINDS[i + 1..] {

                let (style_a, style_b) = (build_chip_style(*a), build_chip_style(*b));

                let differing: Vec<_> = style_a

                    .as_ref()

                    .iter()

                    .zip(style_b.as_ref().iter())

                    .filter(|(x, y)| x != y)

                    .map(|(x, _)| core::mem::discriminant(&x.property))

                    .collect();

                let same_text = a.colors().1 == b.colors().1;

                let expected = if same_text { 1 } else { 2 };

                assert_eq!(

                    differing.len(),

                    expected,

                    "{a:?} vs {b:?}: only the background{} may depend on the kind",

                    if same_text { "" } else { " and the text colour" }

                );

                let bg_differs = style_a

                    .as_ref()

                    .iter()

                    .zip(style_b.as_ref().iter())

                    .any(|(x, y)| x != y && matches!(x.property, CssProperty::BackgroundContent(_)));

                assert!(

                    bg_differs,

                    "{a:?} vs {b:?}: the background must be one of the differing declarations"

                );

            }

        }

    }

    #[test]

    fn build_chip_style_emits_only_finite_non_negative_px_lengths() {

        // Guard the numeric conversions in this file (`isize` -> `PixelValue`):

        // a NaN/inf/negative length must never reach the layout solver.

        for kind in ALL_KINDS {

            let values = all_pixel_values(&build_chip_style(kind));

            assert_eq!(values.len(), 9, "{kind:?}: expected 4 paddings + 4 radii + 1 font size");

            for pv in values {

                let n = px(&pv); // also asserts SizeMetric::Px