//! Split-pane / splitter widget — a two-pane container (horizontal or vertical)

//! holding two arbitrary child `Dom`s with a draggable divider between them that

//! resizes the panes.

//!

//! This is [`crate::widgets::frame::Frame`]'s "two bordered boxes" composed with

//! the pointer-drag state machine of [`crate::widgets::map`] /

//! [`crate::widgets::slider::Slider`]: the drag callbacks live on the **container**

//! (so the cursor stays inside the callback node for the whole drag, exactly like

//! the map's pan), `MouseDown` near the divider begins the drag, `MouseOver` while

//! dragging recomputes the split ratio from the cursor delta and live-resizes the

//! two panes via `set_css_property` (`flex-grow`), and `MouseUp` / `MouseLeave`

//! ends it.

//!

//! ## Layout model

//! The container is a flex row (horizontal split: panes left/right) or column

//! (vertical split: panes top/bottom). Its three children are

//! `[first-pane, divider, second-pane]`. Both panes use `flex-basis: 0` and a

//! `flex-grow` of `ratio` / `1 - ratio`, so they split the container's main-axis

//! space proportionally while the divider keeps its fixed thickness. Dragging

//! rewrites the two `flex-grow` values.

//!

//! ## Drag tracking (mirrors `map::MapTileCache`)

//! The transient drag fields (`is_dragging`, `drag_start_px`, `ratio_at_drag_start`)

//! live in [`SplitPaneStateWrapper`] (not the user-visible [`SplitPaneState`]),

//! the same way the map keeps `drag_anchor` in its cache. On press we record the

//! cursor's main-axis position and the ratio at that moment; each move applies

//! `ratio_at_drag_start + delta / main_size`, so grabbing the divider anywhere

//! keeps it under the cursor (the map's anchor-delta feel).

//!

//! TODO2 / PARTIAL — continuous drag is NOT verifiable in this headless build.

//! Like `map.rs`'s pan, the live resize depends on the runtime delivering

//! `MouseOver` (with a node-relative cursor) repeatedly while the button is held,

//! and on `set_css_property(flex-grow)` triggering a relayout per move — both are

//! GUI-runtime behaviours with no headless test here. The DOM, the divider, the

//! proportional `flex-grow` sizing, and the press/move/release wiring all compile

//! and mirror the proven map/slider pattern exactly; the moment-to-moment motion

//! is the only unverified part. No motion is faked.

//!

//! Key types: [`SplitPane`], [`SplitPaneState`], [`SplitDirection`],

//! [`SplitPaneOnResize`].

use crate::solver3::layout_tree::LayoutNodeId;

use std::vec::Vec;

use azul_core::{

    callbacks::{CoreCallbackData, Update},

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

    geom::{CursorNodePosition, LogicalSize},

    refany::RefAny,

};

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

use azul_css::{

    props::{

        basic::{color::ColorU, FloatValue, PixelValue},

        layout::{LayoutFlexGrow, LayoutFlexDirection, LayoutDisplay, LayoutWidth, LayoutHeight, LayoutOverflow, LayoutFlexBasis, LayoutMinWidth, LayoutMinHeight, LayoutFlexShrink},

        property::{CssProperty, LayoutFlexGrowValue, LayoutWidthValue, LayoutHeightValue, LayoutFlexBasisValue},

        style::{StyleBackgroundContent, StyleBackgroundContentVec, StyleCursor},

    },

    impl_option_inner, AzString,

};

use crate::callbacks::CallbackInfo;

static SPLIT_PANE_CLASS: &[IdOrClass] =

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

static SPLIT_PANE_FIRST_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-split-pane-first"))];

static SPLIT_PANE_DIVIDER_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-split-pane-divider"))];

static SPLIT_PANE_SECOND_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-split-pane-second"))];

/// Orientation of a [`SplitPane`].

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

#[repr(C)]

pub enum SplitDirection {

    /// Panes side by side (left / right); a vertical divider dragged horizontally.

    #[default]

    Horizontal,

    /// Panes stacked (top / bottom); a horizontal divider dragged vertically.

    Vertical,

}

/// Callback function type invoked when the split ratio changes (during a drag).

pub type SplitPaneOnResizeCallbackType =

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

impl_widget_callback!(

    SplitPaneOnResize,

    OptionSplitPaneOnResize,

    SplitPaneOnResizeCallback,

    SplitPaneOnResizeCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        SplitPaneOnResizeCallback,

    info_ty:        CallbackInfo,

    return_ty:      Update,

    default_ret:    Update::DoNothing,

    invoker_static: SPLIT_PANE_ON_RESIZE_INVOKER,

    invoker_ty:     AzSplitPaneOnResizeCallbackInvoker,

    thunk_fn:       az_split_pane_on_resize_callback_thunk,

    setter_fn:      AzApp_setSplitPaneOnResizeCallbackInvoker,

    from_handle_fn: AzSplitPaneOnResizeCallback_createFromHostHandle,

    extra_args:     [ state: SplitPaneState ],

}

/// A two-pane resizable container with a draggable divider.

#[derive(Debug, Clone)]

#[repr(C)]

pub struct SplitPane {

    pub split_pane_state: SplitPaneStateWrapper,

    /// The first pane's content (left for horizontal, top for vertical).

    pub first: Dom,

    /// The second pane's content (right for horizontal, bottom for vertical).

    pub second: Dom,

    /// Style for the outer container.

    pub container_style: CssPropertyWithConditionsVec,

}

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

#[repr(C)]

pub struct SplitPaneStateWrapper {

    /// The user-visible orientation + split ratio.

    pub inner: SplitPaneState,

    /// Optional: function to call when the split ratio changes.

    pub on_resize: OptionSplitPaneOnResize,

    /// `true` while a divider drag is in flight (mirrors `map::MapTileCache::drag_anchor`).

    /// Transient — not part of the user-visible [`SplitPaneState`].

    pub is_dragging: bool,

    /// Cursor main-axis position (relative to the container) at drag start.

    pub drag_start_px: f32,

    /// Split ratio captured at drag start (the anchor for the delta-based update).

    pub ratio_at_drag_start: f32,

}

/// State of a [`SplitPane`]: the orientation and the first pane's size fraction.

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

#[repr(C)]

pub struct SplitPaneState {

    /// Orientation of the split.

    pub direction: SplitDirection,

    /// Fraction `[0, 1]` of the container's main-axis size taken by the FIRST

    /// pane. Clamped to `[MIN_RATIO, MAX_RATIO]` so a pane never fully collapses.

    pub ratio: f32,

}

impl Default for SplitPaneState {

}

// ---- dimensions / limits ----

/// Divider thickness in logical px.

const DIVIDER_THICKNESS: isize = 6;

/// How far (logical px) from the divider centre a press still grabs it.

const GRAB_THRESHOLD: f32 = 9.0;

/// Smallest / largest allowed first-pane fraction (keeps both panes visible).

const MIN_RATIO: f32 = 0.05;

const MAX_RATIO: f32 = 0.95;

// ---- colours ----

/// Divider colour (#adb5bd, mid grey).

const DIVIDER_COLOR: ColorU = ColorU { r: 173, g: 181, b: 189, a: 255 };

const DIVIDER_BG_ITEMS: &[StyleBackgroundContent] = &[StyleBackgroundContent::Color(DIVIDER_COLOR)];

const DIVIDER_BG: StyleBackgroundContentVec =

    StyleBackgroundContentVec::from_const_slice(DIVIDER_BG_ITEMS);

/// `flex-grow: v` as a runtime `CssProperty` (floating-point ratio).

/// The cursor's main-axis (drag-axis) coordinate for the given direction.

    }

/// The container's main-axis (drag-axis) size for the given direction.

    }

/// Builds the outer-container style: a full-size flex box laid out along the

/// split's main axis. Overridable via [`SplitPane::with_container_style`].

    };

    ])

/// Builds a pane's style: `flex-grow: grow; flex-basis: 0` so the two panes split

/// the container's main-axis space proportionally, plus `overflow: hidden` and

/// `min-width/height: 0` so a shrinking pane clips its content instead of forcing

/// the container wider.

            0,

        ))),

    ])

/// Builds the divider's style: fixed thickness, no grow/shrink, a resize cursor

/// matching the drag axis, and a visible fill. The cross-axis size is left to the

/// flex default (stretch), so the divider spans the container.

    };

    ])

impl SplitPane {

    /// Creates a split pane with the two child `Dom`s, split 50/50.

    /// Sets the first-pane fraction, clamped into `[MIN_RATIO, MAX_RATIO]`.

    #[inline]

    /// Builder-style setter for the first-pane fraction.

    #[inline]

    /// Sets the orientation (also refreshes the default container style).

    #[inline]

    /// Builder-style setter for the orientation.

    #[inline]

    /// Replaces the default container style.

    #[inline]

    #[inline]

        );

    #[inline]

    #[inline]

        use azul_core::{

            callbacks::CoreCallback,

            dom::{EventFilter, HoverEventFilter},

            refany::OptionRefAny,

        };

        // One shared RefAny across all pointer callbacks so the transient drag

        // fields set on press are visible to the move/release handlers (RefAny::clone

        // shares the underlying data — same pattern as map.rs / slider.rs).

        ];

        // Children: [first-pane, divider, second-pane] — the order the drag

        // handler relies on (first_child = pane0, then divider, then pane1).

}

impl Default for SplitPane {

        )

}

/// Pointer down → if the press lands near the divider, begin a drag and record

/// the anchor (cursor position + ratio at this moment). A press elsewhere is left

/// alone so it can reach the pane content.

    };

    };

    };

/// Pointer move → while dragging, recompute the ratio from the cursor delta and

/// live-resize the two panes' `flex-grow`, then fire the user's `on_resize`.

    };

    };

    };

    // Resize the two panes. Children are [pane0, divider, pane1]; the callback

    // node (hit node) is the container.

    }

/// Pointer up / leave → end the drag.

impl From<SplitPane> for Dom {

}

#[cfg(test)]

#[allow(

    clippy::float_cmp,

    clippy::too_many_lines,

    clippy::cast_precision_loss,

    clippy::unreadable_literal

)]

mod autotest_generated {

    use std::{

        collections::{BTreeMap, HashMap},

        string::{String, ToString},

        sync::{Arc, Mutex},

    };

    use azul_core::{

        dom::{

            DomId, DomNodeId, EventFilter, FormattingContext, HoverEventFilter, NodeId,

        },

        geom::{LogicalPosition, LogicalRect, OptionLogicalPosition},

        gl::OptionGlContextPtr,

        hit_test::ScrollPosition,

        refany::OptionRefAny,

        resources::RendererResources,

        styled_dom::{NodeHierarchyItemId, StyledDom},

        window::{MonitorVec, RawWindowHandle},

    };

    use azul_css::{props::basic::length::SizeMetric, system::SystemStyle};

    use rust_fontconfig::FcFontCache;

    use super::*;

    #[cfg(feature = "icu")]

    use crate::icu::IcuLocalizerHandle;

    use crate::{

        callbacks::{CallbackChange, CallbackInfoRefData, ExternalSystemCallbacks},

        solver3::{

            display_list::DisplayList,

            geometry::PackedBoxProps,

            layout_tree::{LayoutNodeHot, LayoutTree},

        },

        window::{DomLayoutResult, LayoutWindow},

        window_state::FullWindowState,

    };

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

    // Fixtures / probes

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

    const BOTH_DIRECTIONS: [SplitDirection; 2] =

        [SplitDirection::Horizontal, SplitDirection::Vertical];

    /// Ratios that survive the `[MIN_RATIO, MAX_RATIO]` clamp untouched *and*

    /// round-trip exactly through `FloatValue`'s ×1000 fixed-point encoding.

    const IN_RANGE_RATIOS: [f32; 7] = [0.05, 0.1, 0.25, 0.5, 0.75, 0.9, 0.95];

    fn size(width: f32, height: f32) -> LogicalSize {

        LogicalSize::new(width, height)

    }

    fn cursor(x: f32, y: f32) -> OptionLogicalPosition {

        OptionLogicalPosition::Some(LogicalPosition::new(x, y))

    }

    fn pos(x: f32, y: f32) -> CursorNodePosition {

        CursorNodePosition::new(x, y)

    }

    fn pane(first: Dom, second: Dom) -> SplitPane {

        SplitPane::create(SplitDirection::Horizontal, first, second)

    }

    fn plain(direction: SplitDirection) -> SplitPane {

        SplitPane::create(direction, Dom::create_div(), Dom::create_div())

    }

    fn div_with_class(class: &str) -> Dom {

        Dom::create_div().with_ids_and_classes(vec![Class(AzString::from(class))].into())

    }

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

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

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

    }

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

    fn kinds(v: &CssPropertyWithConditionsVec) -> Vec<core::mem::Discriminant<CssProperty>> {

        v.as_ref()

            .iter()

            .map(|p| core::mem::discriminant(&p.property))

            .collect()

    }

    fn find<T>(

        v: &CssPropertyWithConditionsVec,

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

    ) -> Option<T> {

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

    }

    fn flex_grow_of(p: &CssProperty) -> Option<f32> {

        match p {

            CssProperty::FlexGrow(g) => g.get_property().map(|g| g.inner.get()),

            _ => None,

        }

    }

    /// The raw ×1000 fixed-point encoding behind a `flex-grow` declaration —

    /// the thing that actually saturates, not the `f32` it decodes back to.

    fn flex_grow_raw(p: &CssProperty) -> Option<isize> {

        match p {

            CssProperty::FlexGrow(g) => g.get_property().map(|g| g.inner.number()),

            _ => None,

        }

    }

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

        find(v, flex_grow_of)

    }

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

        find(v, |p| match p {

            CssProperty::FlexShrink(s) => s.get_property().map(|s| s.inner.get()),

            _ => None,

        })

    }

    fn width_pv(v: &CssPropertyWithConditionsVec) -> Option<PixelValue> {

        find(v, |p| match p {

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

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

                _ => None,

            },

            _ => None,

        })

    }

    fn height_pv(v: &CssPropertyWithConditionsVec) -> Option<PixelValue> {

        find(v, |p| match p {

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

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

                _ => None,

            },

            _ => None,

        })

    }

    fn flex_basis_pv(v: &CssPropertyWithConditionsVec) -> Option<PixelValue> {

        find(v, |p| match p {

            CssProperty::FlexBasis(b) => match b.get_property() {

                Some(LayoutFlexBasis::Exact(pv)) => Some(*pv),

                _ => None,

            },

            _ => None,

        })

    }

    fn min_width_pv(v: &CssPropertyWithConditionsVec) -> Option<PixelValue> {

        find(v, |p| match p {

            CssProperty::MinWidth(w) => w.get_property().map(|w| w.inner),

            _ => None,

        })

    }

    fn min_height_pv(v: &CssPropertyWithConditionsVec) -> Option<PixelValue> {

        find(v, |p| match p {

            CssProperty::MinHeight(h) => h.get_property().map(|h| h.inner),

            _ => None,

        })

    }

    fn display(v: &CssPropertyWithConditionsVec) -> Option<LayoutDisplay> {

        find(v, |p| match p {

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

            _ => None,

        })

    }

    fn flex_direction(v: &CssPropertyWithConditionsVec) -> Option<LayoutFlexDirection> {

        find(v, |p| match p {

            CssProperty::FlexDirection(d) => d.get_property().copied(),

            _ => None,

        })

    }

    fn cursor_style(v: &CssPropertyWithConditionsVec) -> Option<StyleCursor> {

        find(v, |p| match p {

            CssProperty::Cursor(c) => c.get_property().copied(),

            _ => None,

        })

    }

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

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

            CssProperty::BackgroundContent(b) => match b.get_property()?.as_ref().first()? {

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

                _ => None,

            },

            _ => None,

        })

    }

    /// `(overflow-x, overflow-y)` declarations, if any.

    fn overflows(v: &CssPropertyWithConditionsVec) -> (Option<LayoutOverflow>, Option<LayoutOverflow>) {

        (

            find(v, |p| match p {

                CssProperty::OverflowX(o) => o.get_property().copied(),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::OverflowY(o) => o.get_property().copied(),

                _ => None,

            }),

        )

    }

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

    /// an `em`/`%` slipping into the divider thickness or the pane's zero basis

    /// would resolve against the parent font/box instead of being fixed.

    fn px(pv: PixelValue) -> f32 {

        assert_eq!(pv.metric, SizeMetric::Px, "expected an absolute px length");

        pv.number.get()

    }

    fn percent(pv: PixelValue) -> f32 {

        assert_eq!(pv.metric, SizeMetric::Percent, "expected a percentage");

        pv.number.get()

    }

    // ---- DOM probes ----

    fn dom_classes(d: &Dom) -> Vec<String> {

        d.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 inline (`with_css_props`) declarations of a rendered node, in order.

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

        d.root

            .style

            .iter_inline_properties()

            .map(|(p, _)| p.clone())

            .collect()

    }

    fn inline_grow(d: &Dom) -> Option<f32> {

        inline_properties(d).iter().find_map(flex_grow_of)

    }

    fn child(d: &Dom, idx: usize) -> &Dom {

        &d.children.as_ref()[idx]

    }

    // ---- callback harness ----

    fn node(idx: usize) -> DomNodeId {

        DomNodeId {

            dom: DomId::ROOT_ID,

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

        }

    }

    fn node_none() -> DomNodeId {

        DomNodeId {

            dom: DomId::ROOT_ID,

            node: NodeHierarchyItemId::NONE,

        }

    }

    fn empty_layout_tree() -> LayoutTree {

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

        }

    }

    /// A `DomLayoutResult` over `styled_dom` in which every `(dom node, size)`

    /// pair in `boxes` has a real laid-out box at the origin — enough for

    /// `get_hit_node_rect()` to report a size. An empty `boxes` models the

    /// "callback fired before the first layout" case (no rect at all).

    fn layout_result(styled_dom: StyledDom, boxes: &[(usize, LogicalSize)]) -> DomLayoutResult {

        let mut lr = DomLayoutResult {

            styled_dom,

            layout_tree: empty_layout_tree(),

            calculated_positions: Vec::new(),

            viewport: LogicalRect::zero(),

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

            scroll_ids: HashMap::new(),

            scroll_id_to_node_id: HashMap::new(),

        };

        for (layout_index, (node_index, used)) in boxes.iter().enumerate() {

            lr.layout_tree

                .dom_to_layout

                .insert(NodeId::new(*node_index), vec![LayoutNodeId::new(layout_index)]);

            lr.layout_tree.nodes.push(LayoutNodeHot {

                box_props: PackedBoxProps::default(),

                dom_node_id: Some(NodeId::new(*node_index)),

                used_size: Some(*used),

                formatting_context: FormattingContext::Flex,

                parent: None,

            });

            lr.calculated_positions.push(LogicalPosition::zero());

        }

        lr

    }

    /// Runs `f` against a real `CallbackInfo` over `styled_dom`, with `hit` as

    /// the hit node and `cur` as the node-relative cursor. Returns `f`'s value

    /// plus every change the callback pushed onto the transaction log.

    fn drive<R>(

        styled_dom: StyledDom,

        boxes: &[(usize, LogicalSize)],

        hit: DomNodeId,

        cur: OptionLogicalPosition,

        f: impl FnOnce(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, boxes));

        let renderer_resources = RendererResources::default();

        let previous_window_state: Option<FullWindowState> = None;

        let current_window_state = FullWindowState::default();

        let gl_context = OptionGlContextPtr::None;

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

            BTreeMap::new();

        let window_handle = RawWindowHandle::Unsupported;

        let system_callbacks = ExternalSystemCallbacks::rust_internal();

        let ref_data = CallbackInfoRefData {

            layout_window: &layout_window,

            renderer_resources: &renderer_resources,

            previous_window_state: &previous_window_state,

            current_window_state: &current_window_state,

            gl_context: &gl_context,

            current_scroll_manager: &scroll_states,

            current_window_handle: &window_handle,

            system_callbacks: &system_callbacks,

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

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

            #[cfg(feature = "icu")]

            icu_localizer: IcuLocalizerHandle::default(),

            ctx: OptionRefAny::None,

        };

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

        let info = CallbackInfo::new(

            &ref_data,

            &changes,

            hit,

            cur,

            OptionLogicalPosition::None,

        );

        let out = f(info);

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

        (out, recorded)

    }

    /// Renders `sp` and hands back both the styled DOM *and* the very `RefAny`

    /// the widget registered on its own pointer callbacks. Driving the handlers

    /// with these two is the real wiring — nothing is rebuilt by hand, so a

    /// mismatch between what `dom()` stores and what the handlers expect cannot

    /// hide behind the fixture.

    fn laid_out(sp: SplitPane) -> (StyledDom, RefAny) {

        let dom = sp.dom();

        let state = dom.root.callbacks.as_ref()[0].refany.clone();

        (StyledDom::create_from_dom(dom), state)

    }

    fn wrapper(state: &mut RefAny) -> SplitPaneStateWrapper {

        let guard = state

            .downcast_ref::<SplitPaneStateWrapper>()

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

        (*guard).clone()

    }

    /// The `(node, flex-grow)` pairs a callback wrote through `set_css_property`.

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

        changes

            .iter()

            .filter_map(|c| match c {

                CallbackChange::ChangeNodeCssProperties {

                    node_id, properties, ..

                } => properties

                    .as_ref()

                    .first()

                    .and_then(flex_grow_of)

                    .map(|g| (*node_id, g)),

                _ => None,

            })

            .collect()

    }

    /// Payload for the user's `on_resize` hook: every state it was handed.

    #[derive(Debug, Default)]

    struct ResizeLog {

        seen: Vec<SplitPaneState>,

    }

    extern "C" fn record_resize(

        mut data: RefAny,

        _info: CallbackInfo,

        state: SplitPaneState,

    ) -> Update {

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

            log.seen.push(state);

        }

        Update::RefreshDom

    }

    extern "C" fn resize_do_nothing(

        _data: RefAny,

        _info: CallbackInfo,

        _state: SplitPaneState,

    ) -> Update {

        Update::DoNothing

    }

    fn logged(log: &mut RefAny) -> Vec<SplitPaneState> {

        let guard = log.downcast_ref::<ResizeLog>().expect("payload type");

        guard.seen.clone()

    }

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

    // flex_grow_prop  (numeric)

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

    #[test]

    fn flex_grow_prop_round_trips_the_representative_ratios() {

        for v in IN_RANGE_RATIOS {

            let got = flex_grow_of(&flex_grow_prop(v)).expect("flex-grow declaration");

            assert!((got - v).abs() < 1e-6, "flex-grow({v}) decoded as {got}");

        }

    }

    #[test]

    fn flex_grow_prop_zero_is_exactly_zero() {

        assert_eq!(flex_grow_raw(&flex_grow_prop(0.0)), Some(0));

        assert_eq!(flex_grow_of(&flex_grow_prop(0.0)), Some(0.0));

        // -0.0 encodes to the same slot (no negative-zero isize).

        assert_eq!(flex_grow_raw(&flex_grow_prop(-0.0)), Some(0));

    }

    #[test]

    fn flex_grow_prop_quantizes_to_three_decimals_by_truncation() {

        // FloatValue stores value * 1000 truncated to an isize.

        assert_eq!(flex_grow_raw(&flex_grow_prop(1.0 / 3.0)), Some(333));

        assert_eq!(flex_grow_raw(&flex_grow_prop(2.0 / 3.0)), Some(666));

        // Sub-precision ratios are indistinguishable from a fully collapsed

        // pane: anything under 0.001 encodes as flex-grow: 0.

        assert_eq!(flex_grow_raw(&flex_grow_prop(0.0009)), Some(0));

        assert_eq!(flex_grow_of(&flex_grow_prop(0.0009)), Some(0.0));

    }

    #[test]

    fn flex_grow_prop_nan_silently_becomes_zero_not_a_panic() {

        // `NaN as isize` saturates to 0, so a NaN ratio does not panic — it

        // renders as `flex-grow: 0`, i.e. a fully collapsed pane.

        assert_eq!(flex_grow_raw(&flex_grow_prop(f32::NAN)), Some(0));

        assert_eq!(flex_grow_of(&flex_grow_prop(f32::NAN)), Some(0.0));

    }

    #[test]

    fn flex_grow_prop_infinities_saturate_to_the_isize_bounds() {

        assert_eq!(flex_grow_raw(&flex_grow_prop(f32::INFINITY)), Some(isize::MAX));

        assert_eq!(

            flex_grow_raw(&flex_grow_prop(f32::NEG_INFINITY)),

            Some(isize::MIN)

        );

        // ...and decode back to a finite (huge) number, never inf/NaN.

        for v in [f32::INFINITY, f32::NEG_INFINITY] {

            let got = flex_grow_of(&flex_grow_prop(v)).expect("flex-grow declaration");

            assert!(got.is_finite(), "flex-grow({v}) decoded as {got}");

        }

    }

    #[test]

    fn flex_grow_prop_f32_extremes_do_not_panic() {

        for v in [

            f32::MAX,

            f32::MIN,

            f32::MIN_POSITIVE,

            -f32::MIN_POSITIVE,

            1.0e30,

            -1.0e30,

            f32::EPSILON,

        ] {

            let got = flex_grow_of(&flex_grow_prop(v)).expect("flex-grow declaration");

            assert!(!got.is_nan(), "flex-grow({v}) decoded as NaN");

        }

        // f32::MAX * 1000 overflows to +inf before the cast, so it saturates

        // exactly like +inf does (no wrap, no debug panic).

        assert_eq!(flex_grow_raw(&flex_grow_prop(f32::MAX)), Some(isize::MAX));

        assert_eq!(flex_grow_raw(&flex_grow_prop(f32::MIN)), Some(isize::MIN));

    }

    #[test]

    fn flex_grow_prop_passes_negative_values_through_unclamped() {

        // The primitive does not clamp: clamping is `set_ratio`'s job.

        assert_eq!(flex_grow_raw(&flex_grow_prop(-1.0)), Some(-1000));

        assert_eq!(flex_grow_of(&flex_grow_prop(-1.0)), Some(-1.0));

        assert_eq!(flex_grow_of(&flex_grow_prop(-0.5)), Some(-0.5));

    }

    #[test]

    fn flex_grow_prop_is_deterministic() {

        for v in [0.0, 0.5, -1.0, f32::NAN, f32::INFINITY] {

            assert_eq!(

                flex_grow_raw(&flex_grow_prop(v)),

                flex_grow_raw(&flex_grow_prop(v))

            );

        }

    }

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

    // main_axis  (other)

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

    #[test]

    fn main_axis_picks_x_for_horizontal_and_y_for_vertical() {

        // Distinct components: an x/y swap cannot hide behind a square input.

        let p = pos(3.0, 7.0);

        assert_eq!(main_axis(SplitDirection::Horizontal, p), 3.0);

        assert_eq!(main_axis(SplitDirection::Vertical, p), 7.0);

    }

    #[test]

    fn main_axis_propagates_nan_and_infinities_verbatim() {

        assert!(main_axis(SplitDirection::Horizontal, pos(f32::NAN, 0.0)).is_nan());

        assert!(main_axis(SplitDirection::Vertical, pos(0.0, f32::NAN)).is_nan());

        assert_eq!(

            main_axis(SplitDirection::Horizontal, pos(f32::INFINITY, 0.0)),

            f32::INFINITY

        );

        assert_eq!(

            main_axis(SplitDirection::Vertical, pos(0.0, f32::NEG_INFINITY)),

            f32::NEG_INFINITY

        );

        // The *other* axis being NaN must not leak into the selected one.

        assert_eq!(main_axis(SplitDirection::Horizontal, pos(5.0, f32::NAN)), 5.0);

        assert_eq!(main_axis(SplitDirection::Vertical, pos(f32::NAN, 5.0)), 5.0);

    }

    #[test]

    fn main_axis_extreme_finite_values_are_exact() {

        for v in [0.0, -0.0, f32::MAX, f32::MIN, 1.0e30, -1.0e30, f32::EPSILON] {

            assert_eq!(main_axis(SplitDirection::Horizontal, pos(v, 1.0)), v);

            assert_eq!(main_axis(SplitDirection::Vertical, pos(1.0, v)), v);

        }

    }

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

    // main_size  (numeric)

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

    #[test]

    fn main_size_picks_width_for_horizontal_and_height_for_vertical() {

        let s = size(11.0, 22.0);

        assert_eq!(main_size(SplitDirection::Horizontal, s), 11.0);

        assert_eq!(main_size(SplitDirection::Vertical, s), 22.0);

    }

    #[test]

    fn main_size_zero_and_negative_pass_straight_through() {

        // The callers - not this helper - reject non-positive sizes.

        assert_eq!(main_size(SplitDirection::Horizontal, size(0.0, 5.0)), 0.0);

        assert_eq!(main_size(SplitDirection::Vertical, size(5.0, 0.0)), 0.0);

        assert_eq!(main_size(SplitDirection::Horizontal, size(-40.0, 5.0)), -40.0);

        assert_eq!(main_size(SplitDirection::Vertical, size(5.0, -40.0)), -40.0);

    }

    #[test]

    fn main_size_nan_and_infinities_do_not_panic() {

        assert!(main_size(SplitDirection::Horizontal, size(f32::NAN, 1.0)).is_nan());

        assert!(main_size(SplitDirection::Vertical, size(1.0, f32::NAN)).is_nan());

        assert_eq!(

            main_size(SplitDirection::Horizontal, size(f32::INFINITY, 1.0)),

            f32::INFINITY

        );

        assert_eq!(

            main_size(SplitDirection::Vertical, size(1.0, f32::NEG_INFINITY)),

            f32::NEG_INFINITY

        );

    }

    #[test]

    fn main_size_nan_slips_past_the_non_positive_guard_the_callers_use() {

        // Both pointer handlers gate on `msize <= 0.0`. NaN fails that

        // comparison, so a NaN container size is treated as usable and

        // poisons every ratio computed from it (see the pointer_move tests).

        let msize = main_size(SplitDirection::Horizontal, size(f32::NAN, 1.0));

        // Spelled out as a binding so the assertion is `!caught`, not a negated

        // partial-ord comparison — the guard below is verbatim what the handlers use.

        let caught_by_the_guard = msize <= 0.0;

        assert!(

            !caught_by_the_guard,

            "NaN must not be caught by the <= 0 guard"

        );

    }

    #[test]

    fn main_size_extreme_finite_values_are_exact() {

        for v in [f32::MAX, f32::MIN, f32::MIN_POSITIVE, 1.0e30, -1.0e30] {

            assert_eq!(main_size(SplitDirection::Horizontal, size(v, 1.0)), v);

            assert_eq!(main_size(SplitDirection::Vertical, size(1.0, v)), v);

        }

    }

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

    // container_style  (other)

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

    #[test]

    fn container_style_declares_a_full_size_flex_box() {

        for dir in BOTH_DIRECTIONS {

            let s = container_style(dir);

            assert_eq!(properties(&s).len(), 7, "{dir:?}");

            assert_eq!(display(&s), Some(LayoutDisplay::Flex), "{dir:?}");

            assert_eq!(grow(&s), Some(1.0), "{dir:?}");

            assert_eq!(percent(width_pv(&s).expect("width")), 100.0, "{dir:?}");

            assert_eq!(percent(height_pv(&s).expect("height")), 100.0, "{dir:?}");

            assert_eq!(

                overflows(&s),

                (Some(LayoutOverflow::Hidden), Some(LayoutOverflow::Hidden)),

                "{dir:?}"

            );

        }

    }

    #[test]

    fn container_style_direction_only_changes_the_flex_direction() {

        let h = container_style(SplitDirection::Horizontal);

        let v = container_style(SplitDirection::Vertical);

        assert_eq!(

            flex_direction(&h),

            Some(LayoutFlexDirection::Row),

            "horizontal splits lay the panes out left/right"

        );

        assert_eq!(

            flex_direction(&v),

            Some(LayoutFlexDirection::Column),

            "vertical splits lay the panes out top/bottom"

        );

        // Same declarations, same order — only the direction value differs.

        assert_eq!(kinds(&h), kinds(&v));

        let (ph, pv) = (properties(&h), properties(&v));

        let differing = ph

            .iter()

            .zip(pv.iter())

            .filter(|(a, b)| a != b)

            .count();

        assert_eq!(differing, 1, "exactly one declaration may depend on the axis");

    }

    #[test]

    fn container_style_is_deterministic() {

        for dir in BOTH_DIRECTIONS {

            assert_eq!(properties(&container_style(dir)), properties(&container_style(dir)));

        }

    }

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

    // pane_style  (numeric)

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

    #[test]

    fn pane_style_declares_the_same_six_properties_for_every_grow() {

        let reference = kinds(&pane_style(0.5));

        assert_eq!(reference.len(), 6);

        for g in [

            0.0,

            1.0,

            -1.0,

            f32::NAN,

            f32::INFINITY,

            f32::NEG_INFINITY,

            f32::MAX,

            f32::MIN,

            1.0e30,

        ] {

            assert_eq!(kinds(&pane_style(g)), reference, "grow = {g}");

        }

    }

    #[test]

    fn pane_style_basis_and_minimums_are_zero_px() {

        let s = pane_style(0.5);

        // flex-basis: 0 is what makes the grow values a *proportion* of the

        // container instead of a share of the leftover space.

        assert_eq!(px(flex_basis_pv(&s).expect("flex-basis")), 0.0);

        assert_eq!(px(min_width_pv(&s).expect("min-width")), 0.0);

        assert_eq!(px(min_height_pv(&s).expect("min-height")), 0.0);

        assert_eq!(

            overflows(&s),

            (Some(LayoutOverflow::Hidden), Some(LayoutOverflow::Hidden))

        );

    }

    #[test]

    fn pane_style_carries_the_grow_through_verbatim() {

        for g in IN_RANGE_RATIOS {

            let got = grow(&pane_style(g)).expect("flex-grow");

            assert!((got - g).abs() < 1e-6, "pane_style({g}) declared {got}");

        }

        assert_eq!(grow(&pane_style(0.0)), Some(0.0));

        assert_eq!(grow(&pane_style(1.0)), Some(1.0));

    }

    #[test]

    fn pane_style_complementary_grows_sum_to_one() {

        // `FloatValue` truncates at 1/1000, so each pane can lose up to 0.001:

        // the pair must still add up to the whole container.

        for r in IN_RANGE_RATIOS {

            let a = grow(&pane_style(r)).expect("first pane grow");

            let b = grow(&pane_style(1.0 - r)).expect("second pane grow");

            assert!(

                (a + b - 1.0).abs() < 3e-3,

                "ratio {r}: {a} + {b} does not fill the container"

            );

        }

    }

    #[test]

    fn pane_style_nan_grow_collapses_the_pane_instead_of_panicking() {

        // A NaN ratio produces NaN for *both* panes (1.0 - NaN is NaN), and

        // both encode as flex-grow: 0 — the split collapses to nothing rather

        // than crashing.

        assert_eq!(grow(&pane_style(f32::NAN)), Some(0.0));

        assert_eq!(grow(&pane_style(1.0 - f32::NAN)), Some(0.0));

    }

    #[test]

    fn pane_style_extreme_grows_do_not_panic() {

        for g in [f32::INFINITY, f32::NEG_INFINITY, f32::MAX, f32::MIN, -1.0e30] {

            let got = grow(&pane_style(g)).expect("flex-grow");

            assert!(got.is_finite(), "pane_style({g}) declared {got}");

        }

    }

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

    // divider_style  (other)

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

    #[test]

    fn divider_style_horizontal_is_a_fixed_width_col_resize_bar() {

        let s = divider_style(SplitDirection::Horizontal);

        assert_eq!(px(width_pv(&s).expect("width")), DIVIDER_THICKNESS as f32);

        assert_eq!(cursor_style(&s), Some(StyleCursor::ColResize));

        // The cross axis is deliberately left to the flex default (stretch).

        assert!(height_pv(&s).is_none(), "vertical size must stay unset");

    }

    #[test]

    fn divider_style_vertical_is_a_fixed_height_row_resize_bar() {

        let s = divider_style(SplitDirection::Vertical);

        assert_eq!(px(height_pv(&s).expect("height")), DIVIDER_THICKNESS as f32);

        assert_eq!(cursor_style(&s), Some(StyleCursor::RowResize));

        assert!(width_pv(&s).is_none(), "horizontal size must stay unset");

    }

    #[test]

    fn divider_style_never_grows_or_shrinks_and_is_visible() {

        for dir in BOTH_DIRECTIONS {

            let s = divider_style(dir);

            assert_eq!(properties(&s).len(), 5, "{dir:?}");

            // A grow/shrink of anything but 0 would let the divider eat the

            // panes' space and silently change the split ratio.

            assert_eq!(grow(&s), Some(0.0), "{dir:?}");

            assert_eq!(shrink(&s), Some(0.0), "{dir:?}");

            assert_eq!(background_color(&s), Some(DIVIDER_COLOR), "{dir:?}");

        }

    }

    #[test]

    fn divider_style_axes_never_agree() {

        let h = divider_style(SplitDirection::Horizontal);

        let v = divider_style(SplitDirection::Vertical);

        assert_ne!(cursor_style(&h), cursor_style(&v));

        assert_ne!(properties(&h), properties(&v));

    }

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

    // SplitPane::create / Default  (constructor)

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

    #[test]

    fn create_starts_centred_idle_and_hookless() {

        for dir in BOTH_DIRECTIONS {

            let sp = plain(dir);

            assert_eq!(sp.split_pane_state.inner.direction, dir);

            assert_eq!(sp.split_pane_state.inner.ratio, 0.5);

            assert!(!sp.split_pane_state.is_dragging, "{dir:?}");

            assert_eq!(sp.split_pane_state.drag_start_px, 0.0, "{dir:?}");

            assert_eq!(sp.split_pane_state.ratio_at_drag_start, 0.0, "{dir:?}");

            assert!(sp.split_pane_state.on_resize.is_none(), "{dir:?}");

            assert_eq!(

                properties(&sp.container_style),

                properties(&container_style(dir)),

                "{dir:?}"

            );