//! Time picker widget — two numeric up/down spinners (hour + minute) side by

//! side with value-clamping, plus an optional AM/PM toggle for 12-hour mode.

//!

//! This is the spinner cousin of [`crate::widgets::number_input`]: each spinner

//! is a small column of an up arrow (`▲`), a value display, and a down arrow

//! (`▼`). Clicking an arrow increments/decrements the value, **clamps** it to

//! its range (hour `0..=23` in 24-hour mode or `1..=12` in 12-hour mode, minute

//! `0..=59`), updates the state, retexts the display node via

//! `info.change_node_text`, and invokes the optional `on_change(state)`.

//!

//! The clamping/retext path mirrors `number_input.rs` (a proven pattern) and the

//! clickable-cell + sibling navigation mirrors `segmented.rs`, so this widget is

//! well-supported. The only deliberate behaviour note:

//!

//! PARTIAL — minute wrap-around does NOT roll into the hour. Per the build spec,

//! incrementing minute past 59 (or below 0) simply clamps; it does not carry

//! into the hour spinner. A carry would require coordinating two sibling

//! displays from one handler, which is doable but out of scope here; clamping is

//! the conservative, non-surprising behaviour.

//!

//! Key types: [`TimePicker`], [`TimePickerState`], [`TimePickerOnChange`].

use azul_core::{

    callbacks::{CoreCallback, CoreCallbackData, Update},

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

    refany::{OptionRefAny, RefAny},

};

use azul_css::dynamic_selector::CssPropertyWithConditions;

use azul_css::dynamic_selector::CssPropertyWithConditionsVec;

use azul_css::{

    props::{

        basic::{color::ColorU, StyleFontSize},

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

        property::{CssProperty, *},

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

    },

    impl_option_inner, AzString,

};

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

// ---- classes ----

static TIME_PICKER_CLASS: &[IdOrClass] =

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

static SPINNER_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-time-picker-spinner"))];

static DISPLAY_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-time-picker-display"))];

static ARROW_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-time-picker-arrow"))];

static SEPARATOR_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-time-picker-separator"))];

static AMPM_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-time-picker-ampm"))];

const UP_ARROW: AzString = AzString::from_const_str("\u{25B2}"); // ▲

const DOWN_ARROW: AzString = AzString::from_const_str("\u{25BC}"); // ▼

const SEPARATOR_TEXT: AzString = AzString::from_const_str(":");

/// Callback type invoked when the hour, minute, or AM/PM value changes.

pub type TimePickerOnChangeCallbackType =

    extern "C" fn(RefAny, CallbackInfo, TimePickerState) -> Update;

impl_widget_callback!(

    TimePickerOnChange,

    OptionTimePickerOnChange,

    TimePickerOnChangeCallback,

    TimePickerOnChangeCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        TimePickerOnChangeCallback,

    info_ty:        CallbackInfo,

    return_ty:      Update,

    default_ret:    Update::DoNothing,

    invoker_static: TIME_PICKER_ON_CHANGE_INVOKER,

    invoker_ty:     AzTimePickerOnChangeCallbackInvoker,

    thunk_fn:       az_time_picker_on_change_callback_thunk,

    setter_fn:      AzApp_setTimePickerOnChangeCallbackInvoker,

    from_handle_fn: AzTimePickerOnChangeCallback_createFromHostHandle,

    extra_args:     [ state: TimePickerState ],

}

/// A time picker: two clamped spinners (hour + minute) and an optional AM/PM

/// toggle.

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

#[repr(C)]

pub struct TimePicker {

    pub state: TimePickerStateWrapper,

    /// Style for the row container.

    pub container_style: CssPropertyWithConditionsVec,

}

/// Wraps [`TimePickerState`] together with its change callback.

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

#[repr(C)]

pub struct TimePickerStateWrapper {

    pub inner: TimePickerState,

    pub on_change: OptionTimePickerOnChange,

}

/// State of a [`TimePicker`].

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

#[repr(C)]

pub struct TimePickerState {

    /// The displayed hour: `0..=23` when [`Self::is_24h`], else `1..=12`.

    pub hour: u32,

    /// The minute, `0..=59`.

    pub minute: u32,

    /// PM flag — only meaningful in 12-hour mode (ignored when `is_24h`).

    pub is_pm: bool,

    /// `true` = 24-hour display (no AM/PM), `false` = 12-hour display + AM/PM.

    pub is_24h: bool,

}

impl Default for TimePickerState {

}

impl TimePickerState {

    /// Returns the hour in canonical 24-hour form (`0..=23`), accounting for the

    /// AM/PM flag in 12-hour mode (12 AM -> 0, 12 PM -> 12).

        } else {

        }

    #[inline]

        } else {

        }

}

// ---- colours ----

const BORDER_COLOR: ColorU = ColorU { r: 206, g: 212, b: 218, a: 255 };

const ARROW_COLOR: ColorU = ColorU { r: 73, g: 80, b: 87, a: 255 };

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

const ACCENT_BG: ColorU = ColorU { r: 13, g: 110, b: 253, a: 255 };

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

const ACCENT_BG_ITEMS: &[StyleBackgroundContent] = &[StyleBackgroundContent::Color(ACCENT_BG)];

const ACCENT_BG_VEC: StyleBackgroundContentVec =

    StyleBackgroundContentVec::from_const_slice(ACCENT_BG_ITEMS);

/// Container: a horizontal row that hugs its content.

static CONTAINER_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::align_self(LayoutAlignSelf::Start)),

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

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

    CssPropertyWithConditions::simple(CssProperty::const_padding_bottom(

        LayoutPaddingBottom::const_px(4),

    )),

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

        6,

    ))),

    CssPropertyWithConditions::simple(CssProperty::const_padding_right(

        LayoutPaddingRight::const_px(6),

    )),

    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 },

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_top_left_radius(

        StyleBorderTopLeftRadius::const_px(6),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_top_right_radius(

        StyleBorderTopRightRadius::const_px(6),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_left_radius(

        StyleBorderBottomLeftRadius::const_px(6),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_right_radius(

        StyleBorderBottomRightRadius::const_px(6),

    )),

];

/// One spinner column: up arrow, value, down arrow.

static SPINNER_STYLE: &[CssPropertyWithConditions] = &[

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

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

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

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

    CssPropertyWithConditions::simple(CssProperty::const_width(LayoutWidth::const_px(40))),

];

/// Up/down arrow cell.

static ARROW_STYLE: &[CssPropertyWithConditions] = &[

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

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

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

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

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

        inner: ARROW_COLOR,

    })),

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

    CssPropertyWithConditions::simple(CssProperty::const_padding_bottom(

        LayoutPaddingBottom::const_px(2),

    )),

];

/// The value display in the middle of a spinner.

static DISPLAY_STYLE: &[CssPropertyWithConditions] = &[

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

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

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

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

        inner: TEXT_COLOR,

    })),

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

    CssPropertyWithConditions::simple(CssProperty::const_padding_bottom(

        LayoutPaddingBottom::const_px(2),

    )),

];

/// The `:` separator between the hour and minute spinners.

static SEPARATOR_STYLE: &[CssPropertyWithConditions] = &[

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

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

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

        inner: TEXT_COLOR,

    })),

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

        2,

    ))),

    CssPropertyWithConditions::simple(CssProperty::const_padding_right(

        LayoutPaddingRight::const_px(2),

    )),

];

/// The clickable AM/PM toggle (12-hour mode only).

static AMPM_STYLE: &[CssPropertyWithConditions] = &[

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

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

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

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

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor { inner: WHITE })),

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

    CssPropertyWithConditions::simple(CssProperty::const_margin_left(LayoutMarginLeft::const_px(8))),

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

    CssPropertyWithConditions::simple(CssProperty::const_padding_bottom(

        LayoutPaddingBottom::const_px(4),

    )),

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

        8,

    ))),

    CssPropertyWithConditions::simple(CssProperty::const_padding_right(

        LayoutPaddingRight::const_px(8),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_top_left_radius(

        StyleBorderTopLeftRadius::const_px(4),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_top_right_radius(

        StyleBorderTopRightRadius::const_px(4),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_left_radius(

        StyleBorderBottomLeftRadius::const_px(4),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_right_radius(

        StyleBorderBottomRightRadius::const_px(4),

    )),

];

impl TimePicker {

    /// Creates a new 24-hour `TimePicker` with the given initial hour (`0..=23`)

    /// and minute (`0..=59`), both clamped into range.

    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // bounded layout/render numeric cast

    /// Switches between 24-hour (no AM/PM) and 12-hour (with AM/PM) display,

    /// re-clamping the hour into the new range.

    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // bounded layout/render numeric cast

    /// Builder variant of [`Self::set_24h`].

    /// Sets the AM/PM flag (only meaningful in 12-hour mode).

    /// Builder variant of [`Self::set_pm`].

    /// Sets the callback invoked when any value changes.

    /// Builder variant of [`Self::set_on_change`].

    /// Replaces `self` with the default value and returns the original.

            ),

            ),

        ];

            } else {

            };

                    )

            );

}

impl Default for TimePicker {

}

/// Builds one spinner column (up arrow / value display / down arrow). The up and

/// down arrows carry the shared `state` `RefAny` and the given click handlers; the

/// middle display is class-tagged so handlers can re-text it.

    use azul_core::dom::{EventFilter, HoverEventFilter};

            )

            ]

        )

/// Shared spinner logic: clamps the targeted field, re-texts the display node

/// (the middle child of the clicked arrow's parent spinner), and fires the

/// optional `on_change`.

#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // bounded layout/render numeric cast

    // The clicked node is an arrow `<p>`; its parent is the spinner; the

    // spinner's first child is the up arrow and the next sibling is the value

    // display `<p>`, whose only child is the re-textable bare text node.

    };

    };

    };

    };

        };

        } else {

            // PARTIAL: minute clamps; it does not wrap/carry into the hour.

        };

            }

        };

    };

/// Toggles the AM/PM flag and re-texts the clicked toggle node. The hit node is

/// the toggle's `<p>` box; the text it wraps is what gets re-texted.

    };

        };

        } else {

        };

            }

        };

    };

impl From<TimePicker> for Dom {

}

#[cfg(test)]

mod autotest_generated {

    use std::{

        collections::{BTreeMap, HashMap},

        sync::{Arc, Mutex},

    };

    use azul_core::{

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

        geom::{LogicalRect, OptionLogicalPosition},

        gl::OptionGlContextPtr,

        hit_test::ScrollPosition,

        resources::RendererResources,

        styled_dom::{NodeHierarchyItemId, StyledDom},

        window::{MonitorVec, RawWindowHandle},

    };

    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,

    };

    // ==================================================================

    // Const-evaluated extremes

    //

    // `canonical_hour` and `hour_bounds` are `const fn`, so evaluating them on

    // states holding the integer extremes in a `const` item makes the compiler

    // itself prove there is no overflow / const-eval panic on those inputs —

    // a stronger statement than any runtime assertion.

    // ==================================================================

    const EXTREME_24H: TimePickerState = TimePickerState {

        hour: u32::MAX,

        minute: u32::MAX,

        is_pm: true,

        is_24h: true,

    };

    const EXTREME_12H: TimePickerState = TimePickerState {

        hour: u32::MAX,

        minute: u32::MAX,

        is_pm: true,

        is_24h: false,

    };

    const _CANONICAL_AT_MAX_24H: u32 = EXTREME_24H.canonical_hour();

    const _CANONICAL_AT_MAX_12H: u32 = EXTREME_12H.canonical_hour();

    const _BOUNDS_AT_MAX_24H: (i64, i64) = EXTREME_24H.hour_bounds();

    const _BOUNDS_AT_MAX_12H: (i64, i64) = EXTREME_12H.hour_bounds();

    // ==================================================================

    // Flattened node layout

    //

    // `convert_dom_into_compact_dom` walks the tree in pre-order, and a time

    // picker is a fixed-shape widget. Every label is a `<p>` box wrapping one

    // bare text node (the widget label convention), so each cell costs two

    // flattened nodes:

    //

    //     container

    //       hour spinner   → [▲ <p> → text, display <p> → text, ▼ <p> → text]

    //       ":" <p> → text

    //       minute spinner → [▲ <p> → text, display <p> → text, ▼ <p> → text]

    //       AM/PM <p> → text   (12-hour mode only)

    //

    // so the flattened indices are constant. `flattened_layout_is_the_fixed

    // _seventeen_or_nineteen_nodes` pins them against the real hierarchy, so the

    // click tests below cannot silently drift onto the wrong node.

    // ==================================================================

    const N_CONTAINER: usize = 0;

    const N_HOUR_SPINNER: usize = 1;

    const N_HOUR_UP: usize = 2;

    const N_HOUR_DISPLAY: usize = 4;

    const N_HOUR_DOWN: usize = 6;

    const N_SEPARATOR: usize = 8;

    const N_MINUTE_SPINNER: usize = 10;

    const N_MINUTE_UP: usize = 11;

    const N_MINUTE_DISPLAY: usize = 13;

    /// The bare text leaf inside the minute display's `<p>` — the node

    /// `adjust_spinner` retexts (the label convention moved the text one

    /// level under the styled wrapper).

    const N_MINUTE_TEXT: usize = 14;

    const N_MINUTE_DOWN: usize = 15;

    const N_AMPM: usize = 17;

    /// The bare text node a label `<p>` wraps — pre-order puts it right after its

    /// box. This is what `change_node_text` has to target.

    const fn text_leaf(label_box: usize) -> usize {

        label_box + 1

    }

    /// Total flattened node count, 24-hour and 12-hour.

    const N_NODES_24H: usize = 17;

    const N_NODES_12H: usize = 19;

    // The class names are part of the widget's public surface: user stylesheets

    // select on them, so a rename is a breaking change and is spelled out here

    // rather than read back out of the statics under test.

    const CLASS_CONTAINER: &str = "__azul-native-time-picker";

    const CLASS_SPINNER: &str = "__azul-native-time-picker-spinner";

    const CLASS_DISPLAY: &str = "__azul-native-time-picker-display";

    const CLASS_ARROW: &str = "__azul-native-time-picker-arrow";

    const CLASS_SEPARATOR: &str = "__azul-native-time-picker-separator";

    const CLASS_AMPM: &str = "__azul-native-time-picker-ampm";

    const UP_GLYPH: &str = "\u{25B2}";

    const DOWN_GLYPH: &str = "\u{25BC}";

    // ==================================================================

    // Harness

    // ==================================================================

    /// 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 `DomNodeId` whose node component is `None` — the "no concrete node was

    /// hit" case that every hierarchy query must decline rather than index.

    fn node_none() -> DomNodeId {

        DomNodeId {

            dom: DomId::ROOT_ID,

            node: NodeHierarchyItemId::NONE,

        }

    }

    /// A `DomLayoutResult` carrying only a `styled_dom`: the time-picker handlers

    /// reach exactly four `CallbackInfo` queries (`get_hit_node`, `get_parent`,

    /// `get_first_child`, `get_next_sibling`), all of which read the node

    /// hierarchy only — 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(),

        }

    }

    /// Runs `f` with a `CallbackInfo` whose window holds `styled_dom` as the root

    /// DOM and whose hit node is `hit`. Returns `f`'s value plus every change the

    /// callback pushed onto the transaction log.

    fn with_info<R>(

        styled_dom: StyledDom,

        hit: DomNodeId,

        f: impl FnOnce(&mut CallbackInfo) -> R,

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

        let mut layout_window =

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

        layout_window

            .layout_results

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

        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(azul_css::system::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 mut info = CallbackInfo::new(

            &ref_data,

            &changes,

            hit,

            OptionLogicalPosition::None,

            OptionLogicalPosition::None,

        );

        let r = f(&mut info);

        let pushed = info.take_changes();

        (r, pushed)

    }

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

    // Tree probes

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

    /// The text a node renders, or `None` for a non-text node.

    fn text_of(dom: &Dom) -> Option<String> {

        // P-wrap transparent (the label convention): a styled `<p>` wraps the

        // bare text leaf, so read through one wrapper level when present.

        dom.root.get_node_type().format().or_else(|| {

            let c = dom.children.as_ref();

            if c.len() == 1 {

                c[0].root.get_node_type().format()

            } else {

                None

            }

        })

    }

    fn classes(dom: &Dom) -> Vec<String> {

        dom.root

            .get_ids_and_classes()

            .as_ref()

            .iter()

            .filter_map(|c| match c {

                Class(s) => Some(s.as_str().to_string()),

                IdOrClass::Id(_) => None,

            })

            .collect()

    }

    /// The classes of a *flattened* node.

    fn flat_classes(sd: &StyledDom, idx: usize) -> Vec<String> {

        sd.node_data.as_ref()[idx]

            .get_ids_and_classes()

            .as_ref()

            .iter()

            .filter_map(|c| match c {

                Class(s) => Some(s.as_str().to_string()),

                IdOrClass::Id(_) => None,

            })

            .collect()

    }

    /// The text of a *flattened* node.

    /// The text a flattened node renders, looking through the `<p>` block

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

    fn flat_text(sd: &StyledDom, idx: usize) -> Option<String> {

        let data = sd.node_data.as_ref();

        match data[idx].get_node_type() {

            NodeType::P => data.get(text_leaf(idx))?.get_node_type().format(),

            other => other.format(),

        }

    }

    /// The recursive `1-per-descendant` total of a `Dom`'s children — what

    /// `estimated_total_children` caches. An under-report makes the flatten

    /// under-allocate its arenas and panic on an out-of-bounds write.

    fn descendants(dom: &Dom) -> usize {

        dom.children

            .as_ref()

            .iter()

            .map(|c| 1 + descendants(c))

            .sum()

    }

    /// The hour column, the separator and the minute column of a rendered picker.

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

        let c = dom.children.as_ref();

        assert!(

            c.len() == 3 || c.len() == 4,

            "a time picker renders hour + ':' + minute (+ AM/PM), got {} children",

            c.len(),

        );

        (&c[0], &c[1], &c[2])

    }

    /// The `(hour, minute)` strings a rendered picker displays.

    fn displayed(dom: &Dom) -> (String, String) {

        let (hour, _, minute) = columns(dom);

        (

            text_of(&hour.children.as_ref()[1]).expect("the hour display is not a text node"),

            text_of(&minute.children.as_ref()[1]).expect("the minute display is not a text node"),

        )

    }

    /// The AM/PM label, or `None` when the widget is in 24-hour mode.

    fn ampm_label(dom: &Dom) -> Option<String> {

        dom.children.as_ref().get(3).and_then(text_of)

    }

    /// Every `RefAny` in the flattened DOM that carries the widget's own state.

    fn state_payloads(sd: &StyledDom) -> Vec<RefAny> {

        let mut out = Vec::new();

        for nd in sd.node_data.as_ref() {

            for cb in nd.callbacks.as_ref() {

                let carries = {

                    let mut r = cb.refany.clone();

                    let carries = r.downcast_ref::<TimePickerStateWrapper>().is_some();

                    carries

                };

                if carries {

                    out.push(cb.refany.clone());

                }

            }

        }

        out

    }

    /// The single shared state `RefAny` the widget baked into its own handlers.

    fn shared_state(sd: &StyledDom) -> RefAny {

        state_payloads(sd)

            .into_iter()

            .next()

            .expect("the rendered time picker carries no TimePickerStateWrapper")

    }

    /// `(flattened node id, payload)` of the node wired to `handler`.

    fn wired_to(sd: &StyledDom, handler: usize) -> (DomNodeId, RefAny) {

        for (i, nd) in sd.node_data.as_ref().iter().enumerate() {

            for cb in nd.callbacks.as_ref() {

                if cb.callback.cb == handler {

                    return (node(i), cb.refany.clone());

                }

            }

        }

        panic!("the rendered time picker has nothing wired to that handler");

    }

    fn read_state(shared: &RefAny) -> TimePickerState {

        let mut s = shared.clone();

        let w = s

            .downcast_ref::<TimePickerStateWrapper>()

            .expect("the widget state changed type");

        w.inner

    }

    /// Renders a picker and hands back its flattened DOM plus the very shared

    /// state its own handlers were wired against — nothing is re-created by

    /// hand, so a mismatch between `dom()` and the handlers cannot hide here.

    fn laid_out(picker: TimePicker) -> (StyledDom, RefAny) {

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

        let shared = shared_state(&styled);

        (styled, shared)

    }

    /// A hand-built shared state, for driving the handlers against values the

    /// public constructors clamp away.

    fn wrapper(inner: TimePickerState) -> RefAny {

        RefAny::new(TimePickerStateWrapper {

            inner,

            on_change: None.into(),

        })

    }

    /// One "mouse-up on `hit`" delivered to `handler`.

    fn press(

        styled_dom: StyledDom,

        payload: &RefAny,

        hit: DomNodeId,

        handler: extern "C" fn(RefAny, CallbackInfo) -> Update,

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

        with_info(styled_dom, hit, |info| handler(payload.clone(), *info))

    }

    /// `times` presses of `handler` against `payload`, all delivered on `hit`.

    fn press_n(

        styled_dom: StyledDom,

        payload: &RefAny,

        hit: DomNodeId,

        handler: extern "C" fn(RefAny, CallbackInfo) -> Update,

        times: usize,

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

        with_info(styled_dom, hit, |info| {

            let mut last = Update::DoNothing;

            for _ in 0..times {

                last = handler(payload.clone(), *info);

            }

            last

        })

    }

    /// The `(target, text)` of every text retext pushed onto the transaction log.

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

        changes

            .iter()

            .filter_map(|c| match c {

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

                    Some((*node_id, text.as_str().to_string()))

                }

                _ => None,

            })

            .collect()

    }

    /// The single retext a spinner/toggle press must push, asserting there is

    /// exactly one and that it is the *only* change of any kind.

    fn only_retext(changes: &[CallbackChange]) -> (DomNodeId, String) {

        let texts = pushed_texts(changes);

        assert_eq!(

            texts.len(),

            1,

            "expected exactly one retext, got {} change(s) total",

            changes.len(),

        );

        assert_eq!(

            changes.len(),

            1,

            "the press pushed {} change(s) beyond its retext",

            changes.len() - 1,

        );

        texts.into_iter().next().unwrap()

    }

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

    // Style probes

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

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

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

    }

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

    // User callbacks

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

    /// A payload the change callback writes into. It arrives as the `data: RefAny`

    /// argument — a *shared* clone of what the test still holds — so the test can

    /// read back exactly what the widget reported, without any global state.

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

    struct ChangeLog {

        seen: Vec<TimePickerState>,

        payload: u32,

    }

    extern "C" fn record_change(

        mut data: RefAny,

        _info: CallbackInfo,

        state: TimePickerState,

    ) -> Update {

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

            log.seen.push(state);

        }

        Update::RefreshDom

    }

    extern "C" fn change_do_nothing(

        _data: RefAny,

        _info: CallbackInfo,

        _state: TimePickerState,

    ) -> Update {

        Update::DoNothing

    }

    extern "C" fn change_refresh_all(

        _data: RefAny,

        _info: CallbackInfo,

        _state: TimePickerState,

    ) -> Update {

        Update::RefreshDomAllWindows

    }

    /// A `Callback`-shaped (2-arg) function — the shape FFI bindings hand in,

    /// which the `From<Callback>` arm *transmutes* into the 3-arg time-picker

    /// slot. Never called.

    extern "C" fn generic_shaped(_data: RefAny, _info: CallbackInfo) -> Update {

        Update::DoNothing

    }

    fn log_refany() -> RefAny {

        RefAny::new(ChangeLog {

            seen: Vec::new(),

            payload: 0xDEAD_BEEF,

        })

    }

    fn read_log(probe: &RefAny) -> ChangeLog {

        let mut probe = probe.clone();

        let log = probe

            .downcast_ref::<ChangeLog>()

            .expect("the user payload changed type");

        log.clone()

    }

    // ==================================================================

    // TimePickerState::canonical_hour

    // ==================================================================

    #[test]

    fn canonical_hour_maps_every_twelve_hour_clock_face_to_its_canonical_hour() {

        // The whole point of the function: `12 AM -> 0` and `12 PM -> 12` are the

        // two cases a naive `hour + 12*pm` gets wrong (it would answer 12 and 24).

        for (hour, is_pm, want) in [

            (12u32, false, 0u32),

            (1, false, 1),

            (11, false, 11),

            (12, true, 12),

            (1, true, 13),

            (11, true, 23),

        ] {

            let s = TimePickerState {

                hour,

                minute: 0,

                is_pm,

                is_24h: false,

            };

            assert_eq!(

                s.canonical_hour(),

                want,

                "{hour} {} is not canonical hour {want}",

                if is_pm { "PM" } else { "AM" },

            );

        }

    }

    #[test]

    fn canonical_hour_round_trips_every_hour_of_the_day_through_the_clock_face() {

        // encode (canonical -> 12-hour face + AM/PM) then decode (canonical_hour)

        // must be the identity across the whole day, or a picker built from a

        // 24-hour timestamp would hand a different hour back to the host.

        for canonical in 0..24u32 {

            let face = if canonical % 12 == 0 { 12 } else { canonical % 12 };

            let s = TimePickerState {

                hour: face,

                minute: 0,

                is_pm: canonical >= 12,

                is_24h: false,

            };

            assert_eq!(

                s.canonical_hour(),

                canonical,

                "the 12-hour encoding of {canonical}:00 did not decode back",

            );

        }

    }

    #[test]

    fn canonical_hour_never_leaves_the_day_in_twelve_hour_mode_for_any_hour() {

        // `hour` is a public `u32` field: nothing stops a host from writing 0, 13

        // or u32::MAX into it. In 12-hour mode the `% 12` must keep the answer a

        // real hour whatever it is handed.

        for hour in [

            0u32,

            1,

            12,

            13,

            23,

            24,

            25,

            59,

            100,

            1_000_000,

            u32::MAX / 2,

            u32::MAX - 1,

            u32::MAX,

        ] {

            for is_pm in [false, true] {

                let s = TimePickerState {

                    hour,

                    minute: 0,

                    is_pm,

                    is_24h: false,

                };

                let c = s.canonical_hour();

                assert!(

                    c < 24,

                    "canonical_hour({hour}, pm={is_pm}) = {c} is not an hour of the day",

                );

            }

        }

    }

    #[test]

    fn canonical_hour_in_24h_mode_returns_the_hour_verbatim() {

        // FINDING (pinned, not weakened): the doc comment promises `0..=23`, but

        // the 24-hour arm is a bare field read with no clamp. Every constructor

        // and setter in this file clamps, so the promise holds for widget-managed

        // state — but a host that writes `state.inner.hour` directly gets its own

        // value straight back out, un-normalised.

        for hour in [0u32, 23, 24, 99, u32::MAX] {

            let s = TimePickerState {

                hour,

                minute: 0,

                is_pm: false,

                is_24h: true,

            };

            assert_eq!(

                s.canonical_hour(),

                hour,

                "the 24-hour arm normalised {hour}, which it has never done",

            );

        }

    }

    #[test]

    fn canonical_hour_ignores_the_pm_flag_in_24h_mode() {

        // A stale `is_pm` left over from a 12-hour session must not shift a

        // 24-hour reading by twelve hours.

        for hour in 0..24u32 {

            let am = TimePickerState {

                hour,

                minute: 0,

                is_pm: false,

                is_24h: true,

            };

            let pm = TimePickerState { is_pm: true, ..am };

            assert_eq!(

                am.canonical_hour(),

                pm.canonical_hour(),

                "the PM flag leaked into the 24-hour reading of hour {hour}",

            );

        }

    }

    #[test]

    fn canonical_hour_does_not_depend_on_the_minute() {

        for minute in [0u32, 30, 59, 60, u32::MAX] {

            for is_24h in [false, true] {

                let s = TimePickerState {

                    hour: 7,

                    minute,

                    is_pm: true,

                    is_24h,

                };

                let baseline = TimePickerState { minute: 0, ..s };

                assert_eq!(

                    s.canonical_hour(),

                    baseline.canonical_hour(),

                    "minute {minute} changed the hour reading (is_24h={is_24h})",

                );

            }

        }

    }

    #[test]

    fn canonical_hour_of_a_default_state_is_midnight() {

        assert_eq!(TimePickerState::default().canonical_hour(), 0);

        assert_eq!(TimePicker::default().state.inner.canonical_hour(), 0);

        assert_eq!(TimePickerStateWrapper::default().inner.canonical_hour(), 0);

    }

    #[test]

    fn canonical_hour_is_total_at_the_u32_extremes() {

        // Const-evaluated above too; this pins the *values* the extremes produce.

        assert_eq!(EXTREME_24H.canonical_hour(), u32::MAX);

        // 4294967295 % 12 == 3, so the 12-hour arm answers 3 PM.

        assert_eq!(EXTREME_12H.canonical_hour(), 15);

    }

    // ==================================================================

    // TimePickerState::hour_bounds

    // ==================================================================

    #[test]

    fn hour_bounds_are_the_two_documented_bands() {

        let mut s = TimePickerState {

            is_24h: true,

            ..Default::default()

        };

        assert_eq!(s.hour_bounds(), (0, 23), "the 24-hour band is wrong");

        s.is_24h = false;

        assert_eq!(s.hour_bounds(), (1, 12), "the 12-hour band is wrong");

    }

    #[test]

    fn hour_bounds_depend_on_nothing_but_the_mode() {

        // If the band ever started depending on the current hour, clamping would

        // become order-dependent and `set_24h` would stop being idempotent.

        for hour in [0u32, 1, 12, 13, 23, u32::MAX] {

            for minute in [0u32, 59, u32::MAX] {

                for is_pm in [false, true] {

                    for is_24h in [false, true] {

                        let s = TimePickerState {

                            hour,

                            minute,

                            is_pm,

                            is_24h,

                        };

                        let want = if is_24h { (0, 23) } else { (1, 12) };

                        assert_eq!(

                            s.hour_bounds(),

                            want,

                            "hour_bounds drifted for {hour}:{minute} pm={is_pm} 24h={is_24h}",

                        );

                    }

                }

            }

        }

    }

    #[test]

    fn hour_bounds_are_ordered_and_fit_in_a_u32() {

        // The bounds are `i64` only so the clamp arithmetic cannot overflow; the

        // cast back to `u32` afterwards is unchecked, so both ends must be

        // non-negative and small.

        for is_24h in [false, true] {

            let s = TimePickerState {

                is_24h,

                ..TimePickerState::default()

            };

            let (lo, hi) = s.hour_bounds();

            assert!(lo <= hi, "hour_bounds({is_24h}) = ({lo}, {hi}) is inverted");

            assert!(lo >= 0, "a negative low bound would cast to a huge u32");

            assert!(hi <= i64::from(u32::MAX), "the high bound does not fit a u32");

            assert!(hi < 24, "the high bound is not an hour of the day");

        }

    }

    #[test]

    fn hour_bounds_agree_with_what_the_constructors_actually_clamp_to() {

        // The band and the clamp are written twice (create / set_24h); a

        // divergence would leave a widget displaying an out-of-band hour.

        let (lo24, hi24) = TimePickerState {

            is_24h: true,

            ..TimePickerState::default()

        }

        .hour_bounds();

        assert_eq!(u32::try_from(lo24).unwrap(), TimePicker::create(0, 0).state.inner.hour);

        assert_eq!(

            u32::try_from(hi24).unwrap(),

            TimePicker::create(u32::MAX, 0).state.inner.hour,

        );