//! Calendar date picker widget.

//!

//! Renders a month header (‹ prev / `Month YYYY` / next ›) above a weekday

//! header row (`Su Mo Tu We Th Fr Sa`) and a 7-column grid of day cells laid

//! out as week rows. The grid is computed from real calendar math — days in

//! month (with leap-year February) and the weekday offset of the 1st (Sakamoto's

//! algorithm) — so the leading blank cells and day count are correct for the

//! given month.

//!

//! Clicking a day cell selects it: the handler reads the cell's baked day

//! number, updates `state.day`, fires the optional `on_change(state)`, and

//! live-restyles the grid (accent fill on the selected cell, neutral on the

//! rest) exactly like `segmented.rs` restyles its active segment. The day number

//! is carried per-cell (like `drop_down.rs`'s per-item data) alongside a clone of

//! the shared-state handle, so selection never depends on re-deriving the grid

//! offset at click time.

//!

//! TODO2 — MONTH NAVIGATION CANNOT REBUILD THE GRID IN-WIDGET.

//! Clicking ‹ / › changes a *different month*, which has a different day count

//! and weekday offset, i.e. a different *number of day-cell nodes*. A widget

//! callback can only `set_css_property` / `change_node_text` on the EXISTING

//! nodes — it cannot add/remove/relayout day cells (the same limitation

//! `combobox`'s type-to-filter hit). Therefore the ‹ / › buttons DO update the

//! month/year in the state and fire `on_change(state)` so host code can rebuild

//! the widget (a fresh `DatePicker::create(...)` with the new month), but the

//! in-widget grid does NOT change, and the header is deliberately NOT re-texted

//! either — showing a new month name over the old day grid would be a misleading

//! half-switch. Day-selection (the restyle) is fully functional for the

//! displayed month; after a ‹ / › without a host rebuild the grid is stale (the

//! documented limitation). Computing the initial grid from calendar math is NOT

//! faked behaviour — only the live month rebuild is the limitation.

//!

//! Key types: [`DatePicker`], [`DatePickerState`], [`DatePickerOnChange`].

use std::vec::Vec;

use azul_core::{

    callbacks::{CoreCallback, CoreCallbackData, Update},

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

    refany::{OptionRefAny, RefAny},

};

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

use azul_css::{

    props::{

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

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

        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 DATE_PICKER_CLASS: &[IdOrClass] =

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

static HEADER_CLASS: &[IdOrClass] =

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

static HEADER_LABEL_CLASS: &[IdOrClass] =

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

static NAV_BTN_CLASS: &[IdOrClass] =

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

static WEEKDAY_ROW_CLASS: &[IdOrClass] =

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

static WEEKDAY_CELL_CLASS: &[IdOrClass] =

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

static GRID_CLASS: &[IdOrClass] =

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

static WEEK_ROW_CLASS: &[IdOrClass] =

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

static DAY_CELL_CLASS: &[IdOrClass] =

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

const PREV_ARROW: AzString = AzString::from_const_str("\u{2039}"); // ‹

const NEXT_ARROW: AzString = AzString::from_const_str("\u{203A}"); // ›

const WEEKDAY_NAMES: [AzString; 7] = [

    AzString::from_const_str("Su"),

    AzString::from_const_str("Mo"),

    AzString::from_const_str("Tu"),

    AzString::from_const_str("We"),

    AzString::from_const_str("Th"),

    AzString::from_const_str("Fr"),

    AzString::from_const_str("Sa"),

];

/// Callback type invoked when the selected day or displayed month/year changes.

pub type DatePickerOnChangeCallbackType =

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

impl_widget_callback!(

    DatePickerOnChange,

    OptionDatePickerOnChange,

    DatePickerOnChangeCallback,

    DatePickerOnChangeCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        DatePickerOnChangeCallback,

    info_ty:        CallbackInfo,

    return_ty:      Update,

    default_ret:    Update::DoNothing,

    invoker_static: DATE_PICKER_ON_CHANGE_INVOKER,

    invoker_ty:     AzDatePickerOnChangeCallbackInvoker,

    thunk_fn:       az_date_picker_on_change_callback_thunk,

    setter_fn:      AzApp_setDatePickerOnChangeCallbackInvoker,

    from_handle_fn: AzDatePickerOnChangeCallback_createFromHostHandle,

    extra_args:     [ state: DatePickerState ],

}

/// A calendar date picker.

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

#[repr(C)]

pub struct DatePicker {

    pub state: DatePickerStateWrapper,

    /// Style for the outer container.

    pub container_style: CssPropertyWithConditionsVec,

}

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

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

#[repr(C)]

pub struct DatePickerStateWrapper {

    pub inner: DatePickerState,

    pub on_change: OptionDatePickerOnChange,

}

/// State of a [`DatePicker`]: the displayed month/year and the selected day.

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

#[repr(C)]

pub struct DatePickerState {

    /// The displayed (and selected) year.

    pub year: u32,

    /// The displayed (and selected) month, `1..=12`.

    pub month: u32,

    /// The selected day of the month, `1..=31`.

    pub day: u32,

}

impl Default for DatePickerState {

}

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

// Pure calendar math (standard, well-known formulas — not faked behaviour).

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

/// Gregorian leap-year test.

/// Number of days in the given (1-based) month of the given year.

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

        2 => {

            } else {

            }

        }

    }

/// Sakamoto's algorithm: weekday of `(year, month, day)`, returned as

/// `0 = Sunday .. 6 = Saturday`. Verified: 2000-01-01 -> 6 (Saturday).

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

    const T: [i32; 12] = [0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4];

    } else {

    };

/// English month name for a 1-based month index.

    const NAMES: [&str; 12] = [

        "January",

        "February",

        "March",

        "April",

        "May",

        "June",

        "July",

        "August",

        "September",

        "October",

        "November",

        "December",

    ];

    } else {

    }

// ---- colours ----

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

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

const MUTED_COLOR: ColorU = ColorU { r: 108, g: 117, b: 125, 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 TRANSPARENT: ColorU = ColorU { r: 0, g: 0, b: 0, a: 0 };

const DAY_SELECTED_BG_ITEMS: &[StyleBackgroundContent] =

    &[StyleBackgroundContent::Color(ACCENT_BG)];

const DAY_SELECTED_BG_VEC: StyleBackgroundContentVec =

    StyleBackgroundContentVec::from_const_slice(DAY_SELECTED_BG_ITEMS);

const TRANSPARENT_BG_ITEMS: &[StyleBackgroundContent] =

    &[StyleBackgroundContent::Color(TRANSPARENT)];

const TRANSPARENT_BG_VEC: StyleBackgroundContentVec =

    StyleBackgroundContentVec::from_const_slice(TRANSPARENT_BG_ITEMS);

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

const WHITE_BG_VEC: StyleBackgroundContentVec =

    StyleBackgroundContentVec::from_const_slice(WHITE_BG_ITEMS);

const CELL_W: isize = 32;

const CELL_H: isize = 28;

/// Outer container: a column that hugs its content, bordered + white.

static CONTAINER_STYLE: &[CssPropertyWithConditions] = &[

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

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

    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(8))),

    CssPropertyWithConditions::simple(CssProperty::const_padding_bottom(

        LayoutPaddingBottom::const_px(8),

    )),

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

        8,

    ))),

    CssPropertyWithConditions::simple(CssProperty::const_padding_right(

        LayoutPaddingRight::const_px(8),

    )),

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

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

    )),

];

/// Header row: prev button / centred label / next button.

static HEADER_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_padding_bottom(

        LayoutPaddingBottom::const_px(6),

    )),

];

/// The ‹ / › nav buttons.

static NAV_BTN_STYLE: &[CssPropertyWithConditions] = &[

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

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

    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: TEXT_COLOR,

    })),

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

];

/// The `Month YYYY` label (centred, fills the header).

static HEADER_LABEL_STYLE: &[CssPropertyWithConditions] = &[

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

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

    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,

    })),

];

/// Weekday header row + cells.

static ROW_STYLE: &[CssPropertyWithConditions] = &[

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

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

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

];

static WEEKDAY_CELL_STYLE: &[CssPropertyWithConditions] = &[

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

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

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

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

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

        inner: MUTED_COLOR,

    })),

    CssPropertyWithConditions::simple(CssProperty::const_padding_bottom(

        LayoutPaddingBottom::const_px(4),

    )),

];

/// Grid: column of week rows.

static GRID_STYLE: &[CssPropertyWithConditions] = &[

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

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

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

];

/// Blank (offset / trailing) cell — keeps the column width, no text/callback.

static BLANK_CELL_STYLE: &[CssPropertyWithConditions] = &[

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

    CssPropertyWithConditions::simple(CssProperty::const_height(LayoutHeight::const_px(CELL_H))),

];

/// Builds the per-day-cell style. Only the background + text colour depend on

/// the selected flag (the rest is shared), so the style is built at runtime

/// (mirrors `segmented::build_segment_style`).

    } else {

    };

            5,

        ))),

        )),

        )),

        )),

        )),

    ])

/// Per-day-cell callback payload: the cell's day number + a clone of the shared

/// state handle (so the handler can update `state.day` + fire `on_change`).

struct DayCellData {

    day: u32,

    state: RefAny,

}

impl DatePicker {

    /// Creates a new `DatePicker` showing `year`/`month` with `day` selected.

    /// `month` is clamped to `1..=12` and `day` to `1..=days_in_month`.

    /// Sets the callback invoked when the selection or month changes.

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

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

}

impl Default for DatePicker {

}

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

            )

                    )),

            ]

        )

                ))

#[allow(clippy::needless_pass_by_value)] // shared RefAny handle cloned per day cell

        }

        );

    }

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

        )

/// Day-cell click handler. Reads the cell's baked day, updates the shared

/// `state.day`, fires `on_change`, and live-restyles the whole grid.

    // Read the baked day + clone the shared-state handle.

        };

    };

        };

            }

        }

    };

/// Accents the clicked cell and neutralises every other grid cell (blanks

/// included — for them transparent bg + a colour on empty text is a no-op).

    };

    };

        }

    }

/// Month navigation. Updates month/year (wrapping across year boundaries),

/// clamps the selected day into the new month, and fires `on_change` so host

/// code can rebuild the widget. TODO2: the in-widget grid is NOT rebuilt (see

/// module docs) — only the reported state changes.

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

    };

    }

impl From<DatePicker> for Dom {

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    #[test]

    #[test]

        // 2000-01-01 was a Saturday (6).

        // 2026-06-01 is a Monday (1).

        // 1970-01-01 was a Thursday (4).

}

#[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 azul_css::props::basic::{length::SizeMetric, pixel::PixelValue};

    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,

    };

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

    // Harness

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

    /// The largest `year` `weekday()` can take before its `y + y / 4` term

    /// overflows `i32`. Sakamoto's accumulator is `i32`, so every input above

    /// this (and below `2^31`, where the `u32 -> i32` cast wraps negative and

    /// the sum becomes small again) is a debug-build overflow panic. Tests stay

    /// strictly inside the safe band; see the report for the finding.

    const MAX_SAFE_WEEKDAY_YEAR: u32 = 1_717_986_916;

    /// 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. `CallbackInfo::set_css_property` *panics* on such an id, so

    /// `restyle_days` must bail out before it ever reaches one.

    fn node_none() -> DomNodeId {

        DomNodeId {

            dom: DomId::ROOT_ID,

            node: NodeHierarchyItemId::NONE,

        }

    }

    /// A `DomLayoutResult` carrying only a `styled_dom`: the date-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 (never assume a flatten index — always look the node up)

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

    /// The three sections a date picker always renders, in order.

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

        let c = dom.children.as_ref();

        assert_eq!(

            c.len(),

            3,

            "a date picker renders header + weekday row + grid, got {} children",

            c.len(),

        );

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

    }

    /// Every cell of the grid, in reading order (blanks included).

    fn grid_cells(grid: &Dom) -> Vec<&Dom> {

        grid.children

            .as_ref()

            .iter()

            .flat_map(|week| week.children.as_ref().iter())

            .collect()

    }

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

    /// label convention mandates; `None` for a non-text node (a blank cell).

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

        match dom.root.get_node_type() {

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

                [only] => only.root.get_node_type().format(),

                _ => None,

            },

            other => other.format(),

        }

    }

    /// The day numbers of a grid in reading order; `None` marks a blank cell.

    fn day_numbers(grid: &Dom) -> Vec<Option<u32>> {

        grid_cells(grid)

            .into_iter()

            .map(|c| text_of(c).map(|t| t.parse::<u32>().expect("a day cell is not a number")))

            .collect()

    }

    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 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 `RefAny` the widget baked into its own shared state (carried by the

    /// nav buttons and by every day cell).

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

        for nd in sd.node_data.as_ref() {

            for cb in nd.callbacks.as_ref() {

                let matches = {

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

                    let matches = r.downcast_ref::<DatePickerStateWrapper>().is_some();

                    matches

                };

                if matches {

                    return cb.refany.clone();

                }

            }

        }

        panic!("the rendered date picker carries no DatePickerStateWrapper");

    }

    /// `(flattened node id, the cell's own payload)` of the day cell showing `day`.

    fn day_cell(sd: &StyledDom, day: u32) -> (DomNodeId, RefAny) {

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

            for cb in nd.callbacks.as_ref() {

                let matches = {

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

                    r.downcast_ref::<DayCellData>().is_some_and(|c| c.day == day)

                };

                if matches {

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

                }

            }

        }

        panic!("the rendered grid has no cell for day {day}");

    }

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

    fn nav_button(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 header has no button wired to that handler");

    }

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

        let mut s = shared.clone();

        let w = s

            .downcast_ref::<DatePickerStateWrapper>()

            .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: DatePicker) -> (StyledDom, RefAny) {

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

        let shared = shared_state(&styled);

        (styled, shared)

    }

    /// One "mouse-up on `hit`" delivered to the widget's own day handler.

    fn click(

        styled_dom: StyledDom,

        payload: &RefAny,

        hit: DomNodeId,

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

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

    }

    /// Drives `times` ‹ / › presses against a hand-built state (the arithmetic in

    /// `month_nav` never touches the DOM, so an empty `StyledDom` suffices) and

    /// returns the state left behind plus the last verdict and all pushed changes.

    fn press_nav(

        inner: DatePickerState,

        next: bool,

        times: usize,

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

        let shared = RefAny::new(DatePickerStateWrapper {

            inner,

            on_change: None.into(),

        });

        let (update, changes) = with_info(StyledDom::default(), node(0), |info| {

            let mut last = Update::DoNothing;

            for _ in 0..times {

                last = if next {

                    on_next_month(shared.clone(), *info)

                } else {

                    on_prev_month(shared.clone(), *info)

                };

            }

            last

        });

        (read_state(&shared), update, changes)

    }

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

    // Style probes

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

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

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

    }

    fn find<T>(

        v: &CssPropertyWithConditionsVec,

        f: impl Fn(&CssProperty) -> Option<T>,

    ) -> Option<T> {

        v.as_ref().iter().find_map(|p| f(&p.property))

    }

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

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

    /// font/box, so a 32x28 cell could render at any size at all — and the seven

    /// columns of a week would stop lining up with the seven weekday headers.

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

        assert_eq!(

            pv.metric,

            SizeMetric::Px,

            "date-picker geometry must be absolute px, got {:?}",

            pv.metric,

        );

        pv.number.get()

    }

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

        find(v, |p| match p {

            CssProperty::Width(w) => match w.get_property() {

                Some(LayoutWidth::Px(pv)) => Some(px(pv)),

                _ => None,

            },

            _ => None,

        })

    }

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

        find(v, |p| match p {

            CssProperty::Height(h) => match h.get_property() {

                Some(LayoutHeight::Px(pv)) => Some(px(pv)),

                _ => None,

            },

            _ => None,

        })

    }

    /// The first declared background colour of a style vec.

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

        find(v, |p| match p {

            CssProperty::BackgroundContent(b) => {

                b.get_property().and_then(|v| match v.as_ref().first() {

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

                    _ => None,

                })

            }

            _ => None,

        })

    }

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

        find(v, |p| match p {

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

            _ => None,

        })

    }

    /// The declared background colour of a *rendered* node's inline style.

    fn rendered_background(dom: &Dom) -> Option<ColorU> {

        dom.root

            .style

            .iter_inline_properties()

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

                CssProperty::BackgroundContent(b) => {

                    b.get_property().and_then(|v| match v.as_ref().first() {

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

                        _ => None,

                    })

                }

                _ => None,

            })

    }

    /// The background colours pushed onto nodes by `restyle_days`, in push order.

    fn pushed_backgrounds(changes: &[CallbackChange]) -> Vec<(NodeId, ColorU)> {

        changes

            .iter()

            .filter_map(|c| match c {

                CallbackChange::ChangeNodeCssProperties {

                    node_id, properties, ..

                } => {

                    let col = properties.as_ref().iter().find_map(|p| match p {

                        CssProperty::BackgroundContent(b) => {

                            b.get_property().and_then(|v| match v.as_ref().first() {

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

                                _ => None,

                            })

                        }

                        _ => None,

                    })?;

                    Some((*node_id, col))

                }

                _ => None,

            })

            .collect()

    }

    /// The text colours pushed onto nodes by `restyle_days`, in push order.

    fn pushed_text_colours(changes: &[CallbackChange]) -> Vec<(NodeId, ColorU)> {

        changes

            .iter()

            .filter_map(|c| match c {

                CallbackChange::ChangeNodeCssProperties {

                    node_id, properties, ..

                } => {

                    let col = properties.as_ref().iter().find_map(|p| match p {

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

                        _ => None,

                    })?;

                    Some((*node_id, col))

                }

                _ => None,

            })

            .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<DatePickerState>,

        payload: u32,

    }

    extern "C" fn record_change(

        mut data: RefAny,

        _info: CallbackInfo,

        state: DatePickerState,

    ) -> 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: DatePickerState,

    ) -> Update {

        Update::DoNothing

    }

    extern "C" fn change_refresh_all(

        _data: RefAny,

        _info: CallbackInfo,

        _state: DatePickerState,

    ) -> 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 date-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()

    }

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

    // is_leap

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

    #[test]

    fn is_leap_applies_all_three_gregorian_rules_including_the_century_exceptions() {

        // The century rule is where naive `% 4` implementations break: 1700/1800/1900

        // are *not* leap years, 1600/2000/2400 are. Getting this wrong silently

        // shifts every date after February by a day.

        for (year, expected) in [

            (1, false),

            (4, true),

            (100, false),

            (400, true),

            (1600, true),

            (1700, false),

            (1800, false),

            (1900, false),

            (2000, true),

            (2023, false),

            (2024, true),

            (2100, false),

            (2400, true),

        ] {

            assert_eq!(is_leap(year), expected, "is_leap({year}) is wrong");

        }

    }

    #[test]

    fn is_leap_is_total_at_the_boundaries_of_u32() {

        // Year 0 satisfies `% 400 == 0`, so the rule says leap; u32::MAX is

        // 4294967295, which is neither `% 4` nor `% 400`. Both must answer without

        // panicking rather than being treated as unreachable.

        assert!(is_leap(0), "year 0 is divisible by 400 and must be leap");

        assert!(

            !is_leap(u32::MAX),

            "u32::MAX (4294967295) is not divisible by 4",

        );

        for year in (u32::MAX - 500)..=u32::MAX {

            // Nothing to compare against here — the point is that no input in the

            // top of the range panics or diverges.

            let _ = is_leap(year);

        }

    }

    #[test]

    fn is_leap_repeats_with_the_400_year_gregorian_cycle() {

        // The whole calendar is periodic mod 400. If any of the three rules is

        // mis-ordered, some year in 0..400 breaks the periodicity.

        for year in 0..1200u32 {

            assert_eq!(

                is_leap(year),

                is_leap(year + 400),

                "the leap rule is not 400-periodic at year {year}",

            );

        }

        // ... and exactly 97 of every 400 years are leap.

        let leaps = (0..400u32).filter(|y| is_leap(*y)).count();

        assert_eq!(leaps, 97, "a 400-year cycle must contain exactly 97 leap years");

    }

    #[test]

    fn is_leap_agrees_with_the_length_of_february() {

        // The two functions encode the same rule twice; a divergence means the grid

        // would show a 28-day February in a year the header calls a leap year.

        for year in 0..800u32 {

            assert_eq!(

                is_leap(year),

                days_in_month(year, 2) == 29,

                "is_leap and days_in_month disagree about February {year}",

            );

        }

    }

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

    // days_in_month

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

    #[test]

    fn days_in_month_returns_the_calendar_length_of_every_real_month() {