//! Titlebar widget for custom window chrome (CSD and title-only modes).

//!

//! Key type: [`Titlebar`]

use azul_core::{

    dom::{Dom, DomVec, IdOrClass, IdOrClass::Class, IdOrClass::Id, IdOrClassVec},

    refany::RefAny,

};

#[allow(clippy::wildcard_imports)] // widget/render module pulls in the css property/value types it builds with

use azul_css::{

    dynamic_selector::{CssPropertyWithConditions, CssPropertyWithConditionsVec},

    props::{

        basic::{

            color::ColorU,

            font::{StyleFontFamily, StyleFontFamilyVec},

            *,

        },

        layout::*,

        property::{CssProperty, *},

        style::*,

    },

    system::{SystemFontType, SystemStyle, TitlebarButtonSide, TitlebarButtons, TitlebarMetrics},

    *,

};

// ── Compile-time defaults (used when no SystemStyle is available) ─────────

// Verified: macOS 11 Big Sur – macOS 15 Sequoia (2020–2025)

#[cfg(target_os = "macos")]

const DEFAULT_TITLEBAR_HEIGHT: f32 = 28.0;

#[cfg(target_os = "windows")]

const DEFAULT_TITLEBAR_HEIGHT: f32 = 32.0;

#[cfg(target_os = "linux")]

const DEFAULT_TITLEBAR_HEIGHT: f32 = 30.0;

#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]

const DEFAULT_TITLEBAR_HEIGHT: f32 = 32.0;

#[cfg(target_os = "macos")]

const DEFAULT_TITLE_FONT_SIZE: f32 = 13.0;

#[cfg(target_os = "windows")]

const DEFAULT_TITLE_FONT_SIZE: f32 = 12.0;

#[cfg(target_os = "linux")]

const DEFAULT_TITLE_FONT_SIZE: f32 = 13.0;

#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]

const DEFAULT_TITLE_FONT_SIZE: f32 = 13.0;

// Verified: macOS 11–15 traffic-light geometry = 78px including gaps

#[cfg(target_os = "macos")]

const DEFAULT_BUTTON_AREA_WIDTH: f32 = 78.0;

// Windows 10/11: 3 buttons x 46px = 138px

#[cfg(target_os = "windows")]

const DEFAULT_BUTTON_AREA_WIDTH: f32 = 138.0;

#[cfg(target_os = "linux")]

const DEFAULT_BUTTON_AREA_WIDTH: f32 = 100.0;

#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]

const DEFAULT_BUTTON_AREA_WIDTH: f32 = 100.0;

// macOS: traffic lights on the left.  All others: right.

#[cfg(target_os = "macos")]

const DEFAULT_BUTTON_SIDE_LEFT: bool = true;

#[cfg(not(target_os = "macos"))]

const DEFAULT_BUTTON_SIDE_LEFT: bool = false;

// Default title text color for light / dark fallback

const DEFAULT_TITLE_COLOR_LIGHT: ColorU = ColorU { r: 76, g: 76, b: 76, a: 255 };  // #4c4c4c

const DEFAULT_TITLE_COLOR_DARK: ColorU = ColorU { r: 229, g: 229, b: 229, a: 255 }; // #e5e5e5

// ── Titlebar ─────────────────────────────────────────────────────────────

/// A titlebar widget with optional close / minimize / maximize

/// buttons, drag-to-move, and double-click-to-maximize.

///

/// # Two modes

///

/// 1. **Title-only** ([`Titlebar::dom`], the default for

///    `WindowDecorations::NoTitleAutoInject`):

///    The OS still draws the native window-control buttons (traffic lights on

///    macOS, caption buttons on Windows).  The titlebar reserves

///    `padding_left` / `padding_right` so the title text doesn't overlap them.

///

/// 2. **Full CSD** ([`Titlebar::dom_with_buttons`], used when

///    `WindowDecorations::None` + `has_decorations`):

///    The titlebar renders its own close / minimize / maximize buttons as

///    regular DOM nodes.  Each button carries a plain `MouseDown` callback

///    that calls `CallbackInfo::modify_window_state()` - exactly the same

///    mechanism used for window dragging.  No special event-system hooks.

///

/// Window-control buttons use `Dom::create_icon("close")` etc. so that

/// icons are resolved through the icon provider system (Material Icons

/// by default) and can be swapped out by registering a different icon pack.

///

/// # Button layout

///

/// `button_side` controls where the buttons appear:

/// - `Left` - macOS traffic-light style (buttons before title)

/// - `Right` - Windows / Linux style (title then buttons)

///

/// # Styling

///

/// The DOM uses CSS classes `.csd-titlebar`, `.csd-title`, `.csd-buttons`,

/// `.csd-button`, `.csd-close`, `.csd-minimize`, `.csd-maximize`.

/// These match the output of `SystemStyle::create_csd_stylesheet()`.

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

#[repr(C)]

pub struct Titlebar {

    /// The title text to display.

    pub title: AzString,

    /// Height of the titlebar in CSS pixels.

    pub height: f32,

    /// Font size for the title text in CSS pixels.

    pub font_size: f32,

    /// Extra padding on the **left** side (px).

    pub padding_left: f32,

    /// Extra padding on the **right** side (px).

    pub padding_right: f32,

    /// Title text color (resolved from SystemStyle.colors.text or platform default).

    pub title_color: ColorU,

}

impl Titlebar {

    /// Create a titlebar with compile-time platform defaults.

    ///

    /// Use [`Titlebar::from_system_style`] when you have a

    /// `SystemStyle` available for pixel-perfect metrics.

    #[inline]

        // Equal padding on both sides keeps text-align:center at the window midpoint.

        // The button-side half prevents overlap; the opposite half balances it.

    /// FFI-compatible alias for [`Titlebar::new`].

    #[inline]

    /// Create a titlebar with a custom height.

    #[inline]

    /// Set the titlebar height.

    #[inline]

    /// Set the title text.

    #[inline]

    /// Swap this titlebar with a default instance, returning the old value.

    #[inline]

    #[must_use]

    /// Create from a live [`SystemStyle`] (for title-only mode, padding

    /// reserves space for OS-drawn buttons).

        // Apply padding_horizontal from TitlebarMetrics

        // Equal padding on both sides so text-align:center stays at the window midpoint.

        // button_area/2 on each side: the button-side half clears the traffic-lights/caption

        // buttons, the opposite half balances the centering offset.

        // Resolve title color from system style, with dark/light fallback

            }

        );

    /// Create from [`SystemStyle`] for **full CSD** mode (no padding - the

    /// buttons are rendered as DOM children).

            }

        );

    /// Build inline CSS for the container div.

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

        ));

        // Titlebar should show grab cursor and prevent text selection

        ));

        ));

    /// Build inline CSS for the title text node.

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

        ]);

        ));

        ));

        // Use resolved title color from SystemStyle (adapts to dark mode)

        ));

        // In CSD mode (flex container), title must grow to fill remaining space

        ));

        ));

        ));

        // Vertically center the text: pad from top by (height - font_size) / 2

    /// Title-only DOM (for `NoTitleAutoInject`).

    ///

    /// The OS draws the native window-control buttons; this just renders

    /// a centred title with drag support.

    #[inline]

    /// Full-CSD DOM with close / minimize / maximize buttons.

    ///

    /// Each button is a div with a `MouseDown` callback that calls

    /// `modify_window_state()` - no special hooks needed.

    /// Inner builder for both modes.

    #[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)

        use azul_core::{

            callbacks::{CoreCallback, CoreCallbackData},

            dom::{EventFilter, HoverEventFilter},

        };

        #[derive(Debug, Clone, Copy)]

        struct DragMarker;

        // Build styles BEFORE moving self.title

        // ── Title node with drag callbacks ──

        // ── Button container (CSD mode only) ──

        } else {

        };

        // ── Root ──

        ]);

        // Button side determines child order:

        //   Left  (macOS):   [buttons] [title]

        //   Right (Win/Lin): [title] [buttons]

            TitlebarButtonSide::Left => {

            }

            TitlebarButtonSide::Right => {

            }

        }

}

/// Build the `.csd-buttons` container with close/min/max button DOM nodes.

#[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)

    use azul_core::{

        callbacks::{CoreCallback, CoreCallbackData},

        dom::{EventFilter, HoverEventFilter},

    };

impl From<Titlebar> for Dom {

}

impl Default for Titlebar {

}

// ── Titlebar callbacks ───────────────────────────────────────────────────

/// All titlebar callbacks: drag, double-click, close, minimize, maximize.

///

/// Every callback is a plain `extern "C"` function that uses

/// `CallbackInfo::modify_window_state()`.  No special hooks needed.

pub(crate) mod callbacks {

    use azul_core::callbacks::Update;

    use azul_core::refany::RefAny;

    use crate::callbacks::CallbackInfo;

    /// `DragStart` - on Wayland, initiate compositor-managed move immediately.

    /// On other platforms, just acknowledge (movement happens in `titlebar_drag`).

        // On Wayland, window position is Uninitialized (compositor hides it).

        // We must use xdg_toplevel_move via begin_interactive_move().

        // MWA-B9 (D2): macOS ALSO takes the native path — the backend maps

        // begin_interactive_move to performWindowDragWithEvent:, which is

        // OS-smooth / snap-aware / multi-monitor-correct; the manual

        // per-event position loop below remains for X11/Windows and as the

        // programmatic fallback.

            // MWA-C-csd: reset the fractional-residual accumulator for the

            // manual move loop (see titlebar_drag).

            // MWA-C-csd: dragging a maximized window restores it first —

            // the native paths get this from the OS drag loop, but the

            // manual loop moved the still-maximized frame around.

        }

    /// MWA-C-csd: fractional-residual carry for the manual drag loop -

    /// rounding alone still loses up to half a pixel per event in a

    /// consistent direction, so very slow trackpad drags crawled. Only one

    /// interactive drag exists at a time and callbacks run on the UI

    /// thread; atomics keep this no_std-friendly (f32 stored as bits).

    static RESIDUAL_X_BITS: core::sync::atomic::AtomicU32 =

        core::sync::atomic::AtomicU32::new(0);

    static RESIDUAL_Y_BITS: core::sync::atomic::AtomicU32 =

        core::sync::atomic::AtomicU32::new(0);

    /// Drag - apply incremental screen-space delta to the CURRENT window position.

    ///

    /// Uses `get_drag_delta_screen_incremental()` (frame-to-frame delta) instead of

    /// `get_drag_delta_screen()` (total delta since drag start). Combined with

    /// the current window position from the OS, this approach is robust against

    /// external position changes during the drag (DPI change, OS clamping,

    /// compositor resize).

    ///

    /// On Wayland: this is a no-op because the compositor manages the move

    /// (initiated by `begin_interactive_move()` in `titlebar_drag_start`).

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

        use azul_core::window::WindowPosition;

        use azul_core::geom::PhysicalPositionI32;

            use core::sync::atomic::Ordering;

            // MWA-C-csd: full fractional-residual carry (upgrades MWA-B9's

            // round-only fix). Each event applies the integer part of

            // delta + residual and carries the remainder, so arbitrarily

            // slow drags advance losslessly.

        // On Wayland: current_pos is Uninitialized, so the if-let doesn't match → no-op.

    /// `DoubleClick` - toggle Maximized ↔ Normal.

        use azul_core::window::WindowFrame;

    /// Close button - `close_requested = true`.

    /// Minimize button - `frame = Minimized`.

        use azul_core::window::WindowFrame;

    /// Maximize button - toggle Maximized ↔ Normal.

        use azul_core::window::WindowFrame;

}

#[cfg(test)]

#[allow(

    clippy::float_cmp,

    clippy::cast_possible_truncation,

    clippy::cast_precision_loss,

    clippy::too_many_lines,

    clippy::unreadable_literal

)]

mod autotest_generated {

    use std::{

        collections::BTreeMap,

        sync::{Arc, Mutex},

    };

    use azul_core::{

        callbacks::Update,

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

        geom::{OptionLogicalPosition, PhysicalPositionI32},

        gl::OptionGlContextPtr,

        hit_test::ScrollPosition,

        refany::OptionRefAny,

        resources::RendererResources,

        styled_dom::NodeHierarchyItemId,

        window::{MonitorVec, RawWindowHandle, WindowFrame, WindowPosition},

    };

    use azul_css::{

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

        system::SafeAreaInsets,

    };

    use rust_fontconfig::FcFontCache;

    use super::*;

    #[cfg(feature = "icu")]

    use crate::icu::IcuLocalizerHandle;

    use crate::{

        callbacks::{CallbackChange, CallbackInfo, CallbackInfoRefData, ExternalSystemCallbacks},

        window::LayoutWindow,

        window_state::FullWindowState,

    };

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

    // Helpers

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

    /// Titles a caller can realistically hand to a titlebar. The widget never

    /// parses, trims or normalises its title, so every one of these has to reach

    /// the DOM byte-for-byte — `AzString` is length-based, so an embedded NUL

    /// must not truncate, and a ZWJ emoji cluster must not be split.

    const ADVERSARIAL_TITLES: [&str; 10] = [

        "",

        " ",

        "My Window",

        "a\0b",

        "\0",

        "e\u{0301}\u{0301}\u{0301}",

        "\u{1F469}\u{200D}\u{1F469}\u{200D}\u{1F467}",

        "\u{202E}gnirts desrever\u{202C}",

        "\u{FFFD}\u{FEFF}\t\n",

        "\u{200B}",

    ];

    /// Every `f32` the numeric surface (`height` / `font_size`) has to survive

    /// *without* tipping the fixed-point encoding over — see

    /// `heights_outside_the_encodable_range_are_not_saturated` for the ones that do.

    const TAME_FLOATS: [f32; 14] = [

        0.0,

        -0.0,

        1.0,

        -1.0,

        0.5,

        -0.5,

        30.0,

        1000.0,

        -1000.0,

        0.999,

        f32::EPSILON,

        f32::MIN_POSITIVE,

        -f32::MIN_POSITIVE,

        f32::NAN,

    ];

    /// The magnitudes that overflow `PixelValue`'s `value * 1000` encoding on

    /// every pointer width: `as isize` saturates them to `isize::MIN`/`MAX`.

    const UNENCODABLE_FLOATS: [f32; 4] =

        [f32::INFINITY, f32::NEG_INFINITY, f32::MAX, f32::MIN];

    /// Every `TitlebarButtonSide`.

    const BOTH_SIDES: [TitlebarButtonSide; 2] =

        [TitlebarButtonSide::Left, TitlebarButtonSide::Right];

    /// Every `WindowFrame` a titlebar callback can be invoked against.

    const ALL_FRAMES: [WindowFrame; 4] = [

        WindowFrame::Normal,

        WindowFrame::Minimized,

        WindowFrame::Maximized,

        WindowFrame::Fullscreen,

    ];

    fn tb(title: &str) -> Titlebar {

        Titlebar::new(AzString::from(title))

    }

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

    }

    /// Every declaration must be unconditional: a titlebar built with a

    /// `@media`/`:hover` guard would silently not apply.

    fn all_unconditional(v: &CssPropertyWithConditionsVec) -> bool {

        v.as_ref().iter().all(|p| p.apply_if.as_ref().is_empty())

    }

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

    /// `em`/`%` height would resolve against the parent font/box instead of the

    /// fixed chrome geometry the titlebar is supposed to reserve.

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

        assert_eq!(

            pv.metric,

            SizeMetric::Px,

            "titlebar geometry must be absolute px, got {:?}",

            pv.metric

        );

        pv.number.get()

    }

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

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

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

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

                _ => None,

            },

            _ => None,

        })

    }

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

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

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

            _ => None,

        })

    }

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

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

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

            _ => None,

        })

    }

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

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

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

            _ => None,

        })

    }

    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 exact container declarations the widget documents, for a given mode.

    fn expected_container(t: &Titlebar, show_buttons: bool) -> Vec<CssProperty> {

        let mut v = Vec::new();

        if show_buttons {

            v.push(CssProperty::const_display(LayoutDisplay::Flex));

            v.push(CssProperty::const_flex_direction(LayoutFlexDirection::Row));

            v.push(CssProperty::const_align_items(LayoutAlignItems::Center));

        } else {

            v.push(CssProperty::const_display(LayoutDisplay::Block));

        }

        v.push(CssProperty::const_height(LayoutHeight::const_px(t.height as isize)));

        v.push(CssProperty::const_cursor(StyleCursor::Grab));

        v.push(CssProperty::user_select(StyleUserSelect::None));

        if t.padding_left > 0.0 {

            v.push(CssProperty::const_padding_left(LayoutPaddingLeft::const_px(

                t.padding_left as isize,

            )));

        }

        if t.padding_right > 0.0 {

            v.push(CssProperty::const_padding_right(LayoutPaddingRight::const_px(

                t.padding_right as isize,

            )));

        }

        v

    }

    /// The exact title declarations the widget documents, for a given mode.

    fn expected_title(t: &Titlebar, show_buttons: bool) -> Vec<CssProperty> {

        let font_family = StyleFontFamilyVec::from_vec(vec![StyleFontFamily::SystemType(

            SystemFontType::TitleBold,

        )]);

        let mut v = vec![

            CssProperty::const_font_size(StyleFontSize::const_px(t.font_size as isize)),

            CssProperty::const_font_family(font_family),

            CssProperty::const_text_color(StyleTextColor { inner: t.title_color }),

        ];

        if show_buttons {

            v.push(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(1)));

            v.push(CssProperty::const_min_width(LayoutMinWidth::const_px(0)));

        }

        v.push(CssProperty::const_text_align(StyleTextAlign::Center));

        v.push(CssProperty::WhiteSpace(StyleWhiteSpaceValue::Exact(

            StyleWhiteSpace::Nowrap,

        )));

        v.push(CssProperty::const_overflow_x(LayoutOverflow::Hidden));

        let v_pad = ((t.height - t.font_size) / 2.0).max(0.0);

        if v_pad > 0.0 {

            v.push(CssProperty::const_padding_top(LayoutPaddingTop::const_px(

                v_pad as isize,

            )));

        }

        v

    }

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

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

        node.root

            .get_ids_and_classes()

            .as_ref()

            .iter()

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

    }

    /// Every id declared on `node`, in order.

    fn ids(node: &Dom) -> Vec<String> {

        node.root

            .get_ids_and_classes()

            .as_ref()

            .iter()

            .filter_map(|c| match c {

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

                Class(_) => None,

            })

            .collect()

    }

    /// Every class declared on `node`, in order.

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

        node.root

            .get_ids_and_classes()

            .as_ref()

            .iter()

            .filter_map(|c| match c {

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

                Id(_) => None,

            })

            .collect()

    }

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

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

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

        match node.root.get_node_type() {

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

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

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

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

                    _ => None,

                },

                _ => None,

            },

            _ => None,

        }

    }

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

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

        match node.root.get_node_type() {

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

            _ => None,

        }

    }

    /// A node's *inline* style properties, in declaration order.

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

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

    }

    /// `(event, callback fn address)` for every callback on `node`, in order.

    fn callbacks_of(node: &Dom) -> Vec<(EventFilter, usize)> {

        node.root

            .get_callbacks()

            .as_ref()

            .iter()

            .map(|c| (c.event, c.callback.cb))

            .collect()

    }

    /// The recursive descendant count. `Dom::estimated_total_children` is a

    /// *cached* value that, if too small, makes `convert_dom_into_compact_dom`

    /// under-allocate its arenas and panic on out-of-bounds writes — so it has to

    /// match this exactly for every button combination.

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

        dom.children.as_ref().iter().map(|c| 1 + count_descendants(c)).sum()

    }

    /// A pre-order, structural fingerprint of a DOM: node type, ids/classes,

    /// `(event, fn address)` per callback and inline declarations. Used instead of

    /// `Dom: PartialEq` because the drag callbacks carry freshly allocated

    /// `RefAny`s, which compare by pointer and so are never equal across builds.

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

        fn walk(d: &Dom, depth: usize, out: &mut Vec<String>) {

            out.push(format!(

                "{depth}|{:?}|{:?}|{:?}|{:?}|{:?}",

                d.root.get_node_type(),

                ids(d),

                classes(d),

                callbacks_of(d),

                inline_props(d),

            ));

            for c in d.children.as_ref() {

                walk(c, depth + 1, out);

            }

        }

        let mut out = Vec::new();

        walk(dom, 0, &mut out);

        out

    }

    /// The title node of a rendered titlebar (the `.csd-title` div).

    fn title_node(dom: &Dom) -> &Dom {

        dom.children

            .as_ref()

            .iter()

            .find(|c| has_class(c, "csd-title"))

            .expect("every titlebar must render a .csd-title node")

    }

    /// The `.csd-buttons` node of a rendered titlebar, if there is one.

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

        dom.children.as_ref().iter().find(|c| has_class(c, "csd-buttons"))

    }

    fn all_button_combinations() -> Vec<TitlebarButtons> {

        let mut out = Vec::new();

        for &close in &[false, true] {

            for &min in &[false, true] {

                for &max in &[false, true] {

                    for &full in &[false, true] {

                        out.push(TitlebarButtons {

                            has_close: close,

                            has_minimize: min,

                            has_maximize: max,

                            has_fullscreen: full,

                        });

                    }

                }

            }

        }

        out

    }

    /// A `SystemStyle` whose titlebar metrics are all "not detected" — the state

    /// `SystemStyle::default()` ships and the one the fallbacks exist for.

    fn blank_system_style() -> SystemStyle {

        SystemStyle::default()

    }

    /// Runs `f` against a `CallbackInfo` backed by `state`, returning `f`'s result

    /// plus every recorded `CallbackChange`. No layout result is inserted: none of

    /// the titlebar callbacks walk the DOM.

    fn with_callback_info<R>(

        state: FullWindowState,

        f: impl FnOnce(CallbackInfo) -> R,

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

        let layout_window =

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

        let renderer_resources = RendererResources::default();

        let previous_window_state: Option<FullWindowState> = None;

        let current_window_state = state;

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

            },

            OptionLogicalPosition::None,

            OptionLogicalPosition::None,

        );

        let out = f(info);

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

        (out, recorded)

    }

    /// The window states pushed through `modify_window_state`, in order.

    fn state_writes(changes: &[CallbackChange]) -> Vec<FullWindowState> {

        changes

            .iter()

            .filter_map(|c| match c {

                CallbackChange::ModifyWindowState { state } => Some(state.clone()),

                _ => None,

            })

            .collect()

    }

    fn interactive_moves(changes: &[CallbackChange]) -> usize {

        changes

            .iter()

            .filter(|c| matches!(c, CallbackChange::BeginInteractiveMove))

            .count()

    }

    fn state_with(frame: WindowFrame, position: WindowPosition) -> FullWindowState {

        let mut s = FullWindowState::default();

        s.flags.frame = frame;

        s.position = position;

        s

    }

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

    // Titlebar::new / Titlebar::create / Default

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

    #[test]

    fn new_uses_the_compile_time_platform_defaults() {

        let t = tb("hello");

        assert_eq!(t.title.as_str(), "hello");

        assert_eq!(t.height, DEFAULT_TITLEBAR_HEIGHT);

        assert_eq!(t.font_size, DEFAULT_TITLE_FONT_SIZE);

        assert_eq!(t.title_color, DEFAULT_TITLE_COLOR_LIGHT);

        assert_eq!(t.padding_left, DEFAULT_BUTTON_AREA_WIDTH / 2.0);

        assert_eq!(t.padding_right, DEFAULT_BUTTON_AREA_WIDTH / 2.0);

    }

    #[test]

    fn new_pads_both_sides_equally_so_centering_lands_at_the_window_midpoint() {

        // The doc comment is explicit: the button-side half clears the OS buttons,

        // the opposite half balances `text-align: center`. Asymmetric padding would

        // push the title off the window midpoint.

        let t = tb("x");

        assert_eq!(

            t.padding_left, t.padding_right,

            "title-only padding must stay symmetric",

        );

        assert!(t.padding_left >= 0.0, "negative reserved space is meaningless");

        assert!(t.height > 0.0 && t.height.is_finite());

        assert!(t.font_size > 0.0 && t.font_size.is_finite());

        assert!(

            t.font_size < t.height,

            "the default font must fit inside the default titlebar height",

        );

    }

    #[test]

    fn new_stores_pathological_titles_byte_for_byte() {

        for title in ADVERSARIAL_TITLES {

            let t = tb(title);

            assert_eq!(t.title.as_str(), title, "the title was mangled or normalised");

            assert_eq!(

                t.title.as_str().len(),

                title.len(),

                "the title was truncated (an embedded NUL must not terminate it)",

            );

        }

    }

    #[test]

    fn new_accepts_a_title_far_longer_than_any_real_window_caption() {

        let huge = "a".repeat(1_000_000);

        let t = Titlebar::new(AzString::from(huge.clone()));

        assert_eq!(t.title.as_str().len(), 1_000_000);

        // ... and it survives the trip into the DOM without being re-encoded.

        let dom = t.dom();

        assert_eq!(text_of(&title_node(&dom).children.as_ref()[0]), Some(huge.as_str()));

    }

    #[test]

    fn create_is_indistinguishable_from_new() {

        for title in ADVERSARIAL_TITLES {

            assert_eq!(

                Titlebar::create(AzString::from(title)),

                Titlebar::new(AzString::from(title)),

                "the FFI alias drifted away from Titlebar::new",

            );

        }

    }

    #[test]

    fn default_is_new_with_an_empty_title() {

        let d = Titlebar::default();

        assert_eq!(d, tb(""));

        assert_eq!(d.title.as_str(), "");

    }

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

    // Titlebar::with_height / Titlebar::set_height

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

    #[test]

    fn with_height_stores_every_float_bit_exactly_and_touches_nothing_else() {

        let base = tb("t");

        for h in TAME_FLOATS.into_iter().chain(UNENCODABLE_FLOATS) {

            let t = Titlebar::with_height(AzString::from("t"), h);

            // to_bits, not `==`: NaN != NaN, and -0.0 == 0.0 would hide a sign flip.

            assert_eq!(

                t.height.to_bits(),

                h.to_bits(),

                "with_height({h}) did not store the value verbatim",

            );

            assert_eq!(t.title.as_str(), "t");

            assert_eq!(t.font_size, base.font_size, "with_height({h}) moved the font size");

            assert_eq!(t.padding_left, base.padding_left, "with_height({h}) moved the padding");

            assert_eq!(t.padding_right, base.padding_right, "with_height({h}) moved the padding");

            assert_eq!(t.title_color, base.title_color, "with_height({h}) moved the colour");

        }

    }

    #[test]

    fn set_height_is_a_bit_exact_last_write_wins_store() {

        let mut t = tb("t");

        let base = tb("t");

        for h in TAME_FLOATS.into_iter().chain(UNENCODABLE_FLOATS) {

            t.set_height(h);

            assert_eq!(t.height.to_bits(), h.to_bits(), "set_height({h}) was not verbatim");

            assert_eq!(t.font_size, base.font_size);

            assert_eq!(t.padding_left, base.padding_left);

            assert_eq!(t.padding_right, base.padding_right);

            assert_eq!(t.title.as_str(), "t", "set_height({h}) disturbed the title");

        }

        // The last write is the one that survives; nothing accumulates.

        t.set_height(7.5);

        t.set_height(9.25);

        assert_eq!(t.height, 9.25);

    }

    #[test]

    fn set_height_zero_and_negative_are_stored_not_clamped() {

        // The setter is documented as a plain store — it is `build_container_style`

        // that has to survive the result, not the setter.

        let mut t = tb("t");

        t.set_height(0.0);

        assert_eq!(t.height.to_bits(), 0_f32.to_bits(), "0.0 must stay +0.0");

        t.set_height(-0.0);

        assert_eq!(t.height.to_bits(), (-0.0_f32).to_bits(), "-0.0 must not be normalised");

        t.set_height(-42.0);

        assert_eq!(t.height, -42.0, "a negative height must not be clamped by the setter");

    }

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

    // Titlebar::set_title

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

    #[test]

    fn set_title_replaces_the_title_and_leaves_the_geometry_alone() {

        let mut t = Titlebar::with_height(AzString::from("first"), 44.0);

        for title in ADVERSARIAL_TITLES {

            t.set_title(AzString::from(title));

            assert_eq!(t.title.as_str(), title);

            assert_eq!(t.title.as_str().len(), title.len());

            assert_eq!(t.height, 44.0, "set_title moved the height");

            assert_eq!(t.padding_left, tb("").padding_left, "set_title moved the padding");

        }

    }

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

    // Titlebar::swap_with_default

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

    #[test]

    fn swap_with_default_hands_back_the_old_value_and_leaves_a_default() {

        let mut t = Titlebar::with_height(AzString::from("payload"), 99.5);

        t.title_color = ColorU { r: 1, g: 2, b: 3, a: 4 };

        let taken = t.swap_with_default();

        assert_eq!(taken.title.as_str(), "payload", "the title did not travel out");

        assert_eq!(taken.height, 99.5, "the height did not travel out");

        assert_eq!(taken.title_color, ColorU { r: 1, g: 2, b: 3, a: 4 });

        assert_eq!(t, Titlebar::default(), "what was left behind is not a default titlebar");

        assert_eq!(t.title.as_str(), "");

    }

    #[test]

    fn swap_with_default_moves_a_nan_height_out_without_losing_its_bits() {

        // `Titlebar` derives PartialEq, so a NaN height makes the struct

        // self-unequal — the swap still has to move the exact bit pattern.

        let mut t = tb("x");

        t.set_height(f32::NAN);

        let taken = t.swap_with_default();

        assert!(taken.height.is_nan(), "the NaN height did not travel out");

        assert_eq!(t.height, DEFAULT_TITLEBAR_HEIGHT, "the leftover kept the NaN");

        assert_eq!(t, Titlebar::default());

    }

    #[test]

    fn repeated_swap_with_default_never_accumulates_state() {

        let mut t = Titlebar::with_height(AzString::from("x"), 1.0);

        let _first = t.swap_with_default();

        for i in 0..8 {

            let taken = t.swap_with_default();

            assert_eq!(taken, Titlebar::default(), "swap #{i} handed back a non-default");

            assert_eq!(t, Titlebar::default(), "swap #{i} left a non-default behind");

        }

        // The drained titlebar still renders a well-formed DOM.

        let dom = t.dom();

        assert_eq!(dom.children.as_ref().len(), 1);

        assert_eq!(text_of(&title_node(&dom).children.as_ref()[0]), Some(""));

    }

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

    // Titlebar::from_system_style

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

    #[test]

    fn from_system_style_falls_back_to_the_compile_time_defaults_when_nothing_is_detected() {

        let ss = blank_system_style();

        let t = Titlebar::from_system_style(AzString::from("sys"), &ss);

        assert_eq!(t.title.as_str(), "sys");

        assert_eq!(t.height, DEFAULT_TITLEBAR_HEIGHT, "an undetected height must fall back");

        // `TitlebarMetrics::default()` *does* carry a font size (13.0), so the

        // compile-time default is only reachable when it is explicitly None.

        assert_eq!(t.font_size, 13.0);

        assert_eq!(t.padding_left, DEFAULT_BUTTON_AREA_WIDTH / 2.0);

        assert_eq!(t.padding_right, DEFAULT_BUTTON_AREA_WIDTH / 2.0);

        assert_eq!(t.title_color, DEFAULT_TITLE_COLOR_LIGHT);

    }

    #[test]