//! Slider / range widget — a horizontal track with a draggable circular thumb

//! that maps a position along the track to a numeric value in `[min, max]`.

//! Combines the value/min/max state + `on_value_change` callback shape of

//! [`crate::widgets::number_input::NumberInput`] with the pointer-drag handling

//! of [`crate::widgets::map`] (cursor-relative-to-node → value), and the

//! switch's "track + knob slid via `margin-left`" rendering.

//!

//! Behaviour: pressing or dragging anywhere on the track sets the value from the

//! cursor's X position (relative to the track, in logical px), slides the thumb

//! live via `set_css_property`, and invokes the user's `on_value_change`.

//!

//! Key types: [`Slider`], [`SliderState`], [`SliderOnValueChange`].

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

use azul_core::{

    callbacks::{CoreCallbackData, Update},

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

    refany::RefAny,

};

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

use azul_css::{

    props::{

        basic::{color::ColorU, *},

        layout::{LayoutDisplay, LayoutFlexDirection, LayoutAlignItems, LayoutAlignSelf, LayoutFlexGrow, LayoutWidth, LayoutHeight, LayoutMarginLeft},

        property::{CssProperty, *},

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

    },

    impl_option_inner, AzString,

};

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

static SLIDER_TRACK_CLASS: &[IdOrClass] =

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

static SLIDER_THUMB_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-slider-thumb"))];

/// Callback function type invoked when the slider value changes.

pub type SliderOnValueChangeCallbackType =

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

impl_widget_callback!(

    SliderOnValueChange,

    OptionSliderOnValueChange,

    SliderOnValueChangeCallback,

    SliderOnValueChangeCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        SliderOnValueChangeCallback,

    info_ty:        CallbackInfo,

    return_ty:      Update,

    default_ret:    Update::DoNothing,

    invoker_static: SLIDER_ON_VALUE_CHANGE_INVOKER,

    invoker_ty:     AzSliderOnValueChangeCallbackInvoker,

    thunk_fn:       az_slider_on_value_change_callback_thunk,

    setter_fn:      AzApp_setSliderOnValueChangeCallbackInvoker,

    from_handle_fn: AzSliderOnValueChangeCallback_createFromHostHandle,

    extra_args:     [ state: SliderState ],

}

/// A horizontal slider with a draggable thumb and a value-change callback.

#[derive(Debug, Clone, PartialEq)]

#[repr(C)]

pub struct Slider {

    pub slider_state: SliderStateWrapper,

    /// Style for the slider track (the horizontal rail).

    pub track_style: CssPropertyWithConditionsVec,

    /// Style for the draggable thumb.

    pub thumb_style: CssPropertyWithConditionsVec,

}

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

#[repr(C)]

pub struct SliderStateWrapper {

    /// Optional: function to call when the value changes.

    pub on_value_change: OptionSliderOnValueChange,

    /// The value/range of this Slider.

    pub inner: SliderState,

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

    /// Transient; not part of the user-visible [`SliderState`].

    pub dragging: bool,

}

/// State of a [`Slider`]: the current value and the allowed `[min, max]` range.

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

#[repr(C)]

pub struct SliderState {

    /// The current value (always within `[min, max]`).

    pub value: f32,

    /// Minimum allowed value (inclusive) — thumb at the far left.

    pub min: f32,

    /// Maximum allowed value (inclusive) — thumb at the far right.

    pub max: f32,

}

impl Default for SliderState {

}

// ---- dimensions (logical px) ----

const TRACK_WIDTH: isize = 200;

const TRACK_HEIGHT: isize = 16;

const TRACK_RADIUS: isize = 8;

const THUMB_SIZE: isize = 16;

const THUMB_RADIUS: isize = 8;

// ---- colours ----

/// Rail colour (#cccccc).

const RAIL_COLOR: ColorU = ColorU {

    r: 204,

    g: 204,

    b: 204,

    a: 255,

};

/// Thumb colour (#0d6efd, accent blue).

const THUMB_COLOR: ColorU = ColorU {

    r: 13,

    g: 110,

    b: 253,

    a: 255,

};

const RAIL_BG_ITEMS: &[StyleBackgroundContent] = &[StyleBackgroundContent::Color(RAIL_COLOR)];

const RAIL_BG: StyleBackgroundContentVec =

    StyleBackgroundContentVec::from_const_slice(RAIL_BG_ITEMS);

const THUMB_BG_ITEMS: &[StyleBackgroundContent] = &[StyleBackgroundContent::Color(THUMB_COLOR)];

const THUMB_BG: StyleBackgroundContentVec =

    StyleBackgroundContentVec::from_const_slice(THUMB_BG_ITEMS);

/// The track (rail) style is parameter-independent, so it lives in a const slice.

static SLIDER_TRACK_STYLE: &[CssPropertyWithConditions] = &[

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

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

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

    CssPropertyWithConditions::simple(CssProperty::align_self(LayoutAlignSelf::Center)),

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

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

    CssPropertyWithConditions::simple(CssProperty::const_height(LayoutHeight::const_px(

        TRACK_HEIGHT,

    ))),

    CssPropertyWithConditions::simple(CssProperty::const_border_top_left_radius(

        StyleBorderTopLeftRadius::const_px(TRACK_RADIUS),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_top_right_radius(

        StyleBorderTopRightRadius::const_px(TRACK_RADIUS),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_left_radius(

        StyleBorderBottomLeftRadius::const_px(TRACK_RADIUS),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_right_radius(

        StyleBorderBottomRightRadius::const_px(TRACK_RADIUS),

    )),

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

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

];

/// Maps a value to a `[0, 1]` fraction along the track.

    } else {

    }

/// Builds the thumb style; the `margin-left` is the only position-dependent

/// property and slides the thumb between the left (`min`) and right (`max`) ends.

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

    // `fraction` is a bare `f32` with no type-level guard. Its only caller feeds

    // it `value_to_fraction`'s already-clamped output, but the helper must be

    // safe on its own terms: `const_px` encodes the margin as `isize * 1000`

    // (`FloatValue::const_new`), so any |margin| above `isize::MAX / 1000`

    // overflows that multiply — a panic in an overflow-checked build, a wrapped

    // and wildly-wrong margin in release. `as isize` already saturates NaN to 0

    // and ±inf to isize::MIN/MAX, so the only thing missing is the clamp into

    // what the fixed-point encoding can actually hold. Clamping the ENCODED px

    // rather than the fraction keeps every in-contract and out-of-contract-but-

    // representable result (including negative fractions) bit-for-bit unchanged.

    const MAX_ENCODABLE_PX: isize = isize::MAX / 1000;

            THUMB_SIZE,

        ))),

            THUMB_SIZE,

        ))),

            0,

        ))),

        )),

        )),

        )),

        )),

        )),

    ])

/// Clamps `value` into `[min, max]`, tolerating the degenerate bounds that

/// `f32::clamp` panics on: an inverted range (`min > max`) is swapped, and a NaN

/// bound is dropped (if both are NaN the value is returned untouched). `min`/`max`

/// are `pub` fields on a `#[repr(C)]` `SliderState` that crosses the C/FFI

/// boundary, so a caller can supply either — and unwinding across FFI is UB.

    };

impl Slider {

    /// Creates a slider with the given current value and `[min, max]` range.

    /// Sets the current value (clamped to the range), recomputing the thumb position.

    #[inline]

    /// Builder-style setter for the current value.

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[inline]

        use azul_core::{

            callbacks::CoreCallback,

            dom::{EventFilter, HoverEventFilter},

            refany::OptionRefAny,

        };

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

        // `dragging` flag set on press is visible to the move/release handlers

        // (RefAny::clone shares the underlying data — same pattern as map.rs).

        ];

            )

}

impl Default for Slider {

}

/// Shared logic for press + drag: compute the value from the cursor's X position

/// relative to the track, slide the thumb live, and invoke the user callback.

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

    };

    // Track width in LOGICAL px (falls back to the design width before first layout).

    // Slide the thumb (first child of the track) to the new position.

    }

/// Pointer down → begin a drag and set the value from the press position.

    };

/// Pointer move → if a drag is active, track the value to the cursor.

    };

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

impl From<Slider> for Dom {

}

// ────────── Adversarial autotest coverage ────────────────────────────

//

// The slider is a pure `f32 -> fraction -> whole-pixel margin` pipeline wrapped

// in three pointer callbacks. Everything below feeds it values a real app (or an

// FFI caller writing the `#[repr(C)]` `pub` fields directly) can produce — an

// inverted `[min, max]`, a NaN bound, an infinite range, a cursor outside the

// track, a zero-width track, a foreign payload — and asserts the widget

// *contains* them instead of panicking or sliding the thumb off the rail.

#[cfg(all(test, feature = "std"))]

#[allow(

    clippy::float_cmp,

    clippy::cast_precision_loss,

    clippy::cast_possible_truncation,

    clippy::unreadable_literal,

    clippy::too_many_lines

)]

mod autotest_generated {

    use std::{

        collections::{BTreeMap, HashMap},

        mem::discriminant,

        panic::{catch_unwind, AssertUnwindSafe},

        sync::{Arc, Mutex},

    };

    use azul_core::{

        dom::{

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

        },

        geom::{LogicalPosition, LogicalRect, LogicalSize, OptionLogicalPosition},

        gl::OptionGlContextPtr,

        hit_test::ScrollPosition,

        refany::OptionRefAny,

        resources::RendererResources,

        styled_dom::{NodeHierarchyItemId, StyledDom},

        window::{MonitorVec, RawWindowHandle},

    };

    use azul_css::props::basic::{length::SizeMetric, pixel::PixelValue};

    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

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

    /// The travel the thumb has along the design-width track: a thumb at

    /// `fraction == 1.0` must sit flush against the right end, not past it.

    const TRAVEL: f32 = (TRACK_WIDTH - THUMB_SIZE) as f32; // 184.0

    /// The whole design width of the track, as an `f32` — the value

    /// `apply_cursor_value` falls back to before the first layout.

    const DESIGN_WIDTH: f32 = TRACK_WIDTH as f32; // 200.0

    /// Fractions `value_to_fraction` can actually hand to `build_thumb_style`:

    /// the closed unit interval (plus both signed zeroes) and NaN, which is what

    /// a NaN value/bound collapses to. Nothing else is reachable through the

    /// public API — the out-of-contract extremes get their own probe.

    const REACHABLE_FRACTIONS: [f32; 10] = [

        0.0,

        -0.0,

        f32::MIN_POSITIVE,

        f32::EPSILON,

        0.001,

        0.25,

        0.5,

        0.75,

        1.0,

        f32::NAN,

    ];

    /// `[min, max]` ranges a caller can legally build (`min <= max`, both finite).

    const SANE_RANGES: [(f32, f32); 8] = [

        (0.0, 100.0),

        (0.0, 1.0),

        (-100.0, -50.0),

        (-50.0, 50.0),

        (0.0, 0.0),

        (-7.5, 7.5),

        (1.0, 1.0e9),

        (-1.0e9, 1.0e9),

    ];

    /// Ranges that break `f32::clamp`'s `min <= max` precondition. Every one of

    /// them is expressible: `SliderState`'s `min`/`max` are `pub` fields on a

    /// `#[repr(C)]` struct that crosses the C/FFI boundary.

    const DEGENERATE_RANGES: [(f32, f32); 6] = [

        (100.0, 0.0),

        (1.0, -1.0),

        (f32::NAN, 100.0),

        (0.0, f32::NAN),

        (f32::NAN, f32::NAN),

        (f32::INFINITY, f32::NEG_INFINITY),

    ];

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

    // Style-vec probes

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

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

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

    }

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

    /// An `em`/`%` slipping into the thumb offset would resolve against the

    /// parent font/box, so "92px along the rail" could land anywhere.

    fn px(pv: PixelValue) -> f32 {

        assert_eq!(

            pv.metric,

            SizeMetric::Px,

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

            pv.metric,

        );

        pv.number.get()

    }

    /// The declared `margin-left` of a style vec — the thumb's position.

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

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

            CssProperty::MarginLeft(m) => m.get_property().map(|m| px(m.inner)),

            _ => None,

        })

    }

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

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

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

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

                _ => None,

            },

            _ => None,

        })

    }

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

        })

    }

    /// The thumb offset a freshly built widget declares.

    fn thumb_margin(s: &Slider) -> f32 {

        margin_left(&s.thumb_style).expect("the thumb style must declare a margin-left")

    }

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

    }

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

        dom.root

            .style

            .iter_inline_properties()

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

            .collect()

    }

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

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

        }

    }

    /// A layout result carrying only the styled DOM: the hierarchy is real (so

    /// `get_first_child` resolves the thumb) but nothing is laid out, so

    /// `get_hit_node_rect` returns `None` — the pre-first-layout state a widget

    /// is in when the very first `MouseDown` arrives.

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

        }

    }

    /// The same DOM, but laid out: node 0 (the track) reports `track` as its

    /// used size, so `get_hit_node_rect` yields a real width.

    fn laid_out_at(styled_dom: StyledDom, track: LogicalSize) -> DomLayoutResult {

        let hot = |dom_node: usize, size: LogicalSize, parent: Option<usize>| LayoutNodeHot {

            box_props: PackedBoxProps::default(),

            dom_node_id: Some(NodeId::new(dom_node)),

            used_size: Some(size),

            formatting_context: FormattingContext::Flex,

            parent,

        };

        let mut dom_to_layout = BTreeMap::new();

        dom_to_layout.insert(NodeId::new(0), vec![LayoutNodeId::new(0)]);

        dom_to_layout.insert(NodeId::new(1), vec![LayoutNodeId::new(1)]);

        let mut result = unlaid(styled_dom);

        result.layout_tree.nodes = vec![

            hot(0, track, None),

            hot(1, LogicalSize::new(THUMB_SIZE as f32, THUMB_SIZE as f32), Some(0)),

        ];

        result.layout_tree.dom_to_layout = dom_to_layout;

        result.calculated_positions = vec![LogicalPosition::zero(), LogicalPosition::zero()];

        result

    }

    /// Runs `f` with a real `CallbackInfo` over `layout`, hitting `hit`, with

    /// `cursor` reported as the cursor position relative to the hit node.

    /// Returns `f`'s value plus everything the callback pushed onto the log.

    fn with_info<R>(

        layout: DomLayoutResult,

        hit: DomNodeId,

        cursor: OptionLogicalPosition,

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

        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,

            cursor,

            OptionLogicalPosition::None,

        );

        let out = f(&mut info);

        let pushed = info.take_changes();

        (out, pushed)

    }

    /// Renders `slider` and hands back the styled DOM *plus the very `RefAny`

    /// the widget registered on its own handlers* — driving the callbacks with

    /// these two is the real wiring, so a mismatch between what `dom()` stores

    /// and what the handlers expect cannot hide behind the fixture.

    fn wired(slider: Slider) -> (StyledDom, RefAny) {

        let dom = slider.dom();

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

        (StyledDom::create_from_dom(dom), state)

    }

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

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

    }

    /// One pointer event of `kind` delivered to the widget's own handler.

    fn deliver(

        slider: Slider,

        state: &RefAny,

        hit: DomNodeId,

        at: OptionLogicalPosition,

        track: Option<LogicalSize>,

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

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

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

        let layout = match track {

            Some(t) => laid_out_at(styled, t),

            None => unlaid(styled),

        };

        with_info(layout, hit, at, |info| kind(state.clone(), *info))

    }

    /// A press at `x` on a never-laid-out slider — the common path.

    fn press_at(slider: Slider, x: f32) -> (Update, Vec<CallbackChange>, SliderStateWrapper) {

        let (styled, state) = wired(slider);

        let (update, changes) = with_info(unlaid(styled), node(0), cursor(x, 8.0), |info| {

            on_slider_pointer_down(state.clone(), *info)

        });

        (update, changes, read_state(&state))

    }

    fn read_state(state: &RefAny) -> SliderStateWrapper {

        let mut state = state.clone();

        let wrapper = state

            .downcast_ref::<SliderStateWrapper>()

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

        wrapper.clone()

    }

    /// Every `(node, margin-left)` pair a callback pushed onto the change log.

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

        changes

            .iter()

            .filter_map(|c| match c {

                CallbackChange::ChangeNodeCssProperties {

                    node_id, properties, ..

                } => properties

                    .as_ref()

                    .iter()

                    .find_map(|p| match p {

                        CssProperty::MarginLeft(m) => m.get_property().map(|m| px(m.inner)),

                        _ => None,

                    })

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

                _ => None,

            })

            .collect()

    }

    /// What `apply_cursor_value` is documented to compute: the cursor fraction

    /// of the track, mapped onto `[min, max]`. `mul_add` (not `a * b + c`) so

    /// the expectation is bit-identical to the implementation.

    fn expected_value(x: f32, width: f32, min: f32, max: f32) -> f32 {

        (x / width).clamp(0.0, 1.0).mul_add(max - min, min)

    }

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

    // User-hook probes

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

    /// A payload the value-change hook writes into. It arrives as the `data`

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

    /// reads back exactly what the widget passed, with no global state.

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

    struct ValueLog {

        seen: Vec<SliderState>,

    }

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

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

            log.seen.push(state);

        }

        Update::RefreshDom

    }

    extern "C" fn value_do_nothing(_: RefAny, _: CallbackInfo, _: SliderState) -> Update {

        Update::DoNothing

    }

    extern "C" fn value_refresh_all(_: RefAny, _: CallbackInfo, _: SliderState) -> 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 slider slot.

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

        Update::DoNothing

    }

    fn log_refany() -> RefAny {

        RefAny::new(ValueLog::default())

    }

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

        let mut probe = probe.clone();

        let log = probe

            .downcast_ref::<ValueLog>()

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

        log.clone()

    }

    fn hook_ptr(s: &Slider) -> Option<usize> {

        s.slider_state

            .on_value_change

            .as_ref()

            .map(|h| h.callback.cb as *const () as usize)

    }

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

    // value_to_fraction  (numeric)

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

    #[test]

    fn value_to_fraction_maps_the_endpoints_and_the_midpoint_exactly() {

        assert_eq!(value_to_fraction(0.0, 0.0, 100.0), 0.0);

        assert_eq!(value_to_fraction(100.0, 0.0, 100.0), 1.0);

        assert_eq!(value_to_fraction(50.0, 0.0, 100.0), 0.5);

        assert_eq!(value_to_fraction(25.0, 0.0, 100.0), 0.25);

        // A range that does not start at zero catches a `value / max` shortcut.

        assert_eq!(value_to_fraction(150.0, 100.0, 200.0), 0.5);

        assert_eq!(value_to_fraction(-75.0, -100.0, -50.0), 0.5);

    }

    #[test]

    fn value_to_fraction_clamps_instead_of_letting_the_thumb_leave_the_rail() {

        for (value, min, max) in [

            (200.0_f32, 0.0_f32, 100.0_f32),

            (-1.0, 0.0, 100.0),

            (1.0e30, 0.0, 1.0),

            (-1.0e30, 0.0, 1.0),

            (f32::MAX, -1.0, 1.0),

            (f32::MIN, -1.0, 1.0),

        ] {

            let f = value_to_fraction(value, min, max);

            assert!(

                (0.0..=1.0).contains(&f),

                "value_to_fraction({value}, {min}, {max}) = {f} is outside [0, 1]",

            );

        }

        assert_eq!(value_to_fraction(200.0, 0.0, 100.0), 1.0);

        assert_eq!(value_to_fraction(-1.0, 0.0, 100.0), 0.0);

    }

    #[test]

    fn value_to_fraction_guards_the_zero_width_and_inverted_range() {

        // `max <= min` is the documented guard: a zero-width range would be a

        // division by zero (0/0 = NaN, x/0 = ±inf) and an inverted one would

        // run the fraction backwards.

        for (value, min, max) in [

            (0.0_f32, 0.0_f32, 0.0_f32),

            (5.0, 5.0, 5.0),

            (-5.0, -5.0, -5.0),

            (1.0e9, 7.0, 7.0),

            (50.0, 100.0, 0.0),

            (50.0, 1.0, -1.0),

        ] {

            assert_eq!(

                value_to_fraction(value, min, max),

                0.0,

                "a degenerate range [{min}, {max}] must pin the thumb left",

            );

        }

    }

    #[test]

    fn value_to_fraction_is_monotonic_across_the_whole_range() {

        // A sign slip in `(value - min) / (max - min)` still returns values in

        // [0, 1] — only the ordering catches a reversed rail.

        let mut previous = f32::NEG_INFINITY;

        for i in -50..=150 {

            let f = value_to_fraction(i as f32, 0.0, 100.0);

            assert!(

                f >= previous,

                "the fraction went backwards at value = {i} ({f} < {previous})",

            );

            previous = f;

        }

        assert_eq!(previous, 1.0);

    }

    #[test]

    fn value_to_fraction_nan_inputs_do_not_panic_and_stay_nan() {

        // `f32::clamp` only asserts on its *bounds* (0.0/1.0 here), so a NaN

        // `self` propagates rather than panicking. Downstream,

        // `build_thumb_style` turns that NaN into a zero margin.

        assert!(value_to_fraction(f32::NAN, 0.0, 100.0).is_nan());

        // A NaN bound makes `max <= min` false, so the guard does *not* fire and

        // the arithmetic produces NaN — still no panic.

        assert!(value_to_fraction(50.0, f32::NAN, 100.0).is_nan());

        assert!(value_to_fraction(50.0, 0.0, f32::NAN).is_nan());

        assert!(value_to_fraction(f32::NAN, f32::NAN, f32::NAN).is_nan());

    }

    #[test]

    fn value_to_fraction_never_escapes_the_unit_interval_for_any_input() {

        // The only contract that matters downstream: the result is either NaN

        // (which `build_thumb_style` casts to a 0 margin) or a real fraction.

        // Anything else slides the thumb off the track.

        let interesting = [

            0.0_f32,

            -0.0,

            1.0,

            -1.0,

            50.0,

            f32::MIN_POSITIVE,

            f32::EPSILON,

            f32::MAX,

            f32::MIN,

            f32::INFINITY,

            f32::NEG_INFINITY,

            f32::NAN,

        ];

        for value in interesting {

            for min in interesting {

                for max in interesting {

                    let f = value_to_fraction(value, min, max);

                    assert!(

                        f.is_nan() || (0.0..=1.0).contains(&f),

                        "value_to_fraction({value}, {min}, {max}) = {f} escaped [0, 1]",

                    );

                }

            }

        }

    }

    #[test]

    fn value_to_fraction_infinite_bounds_produce_a_defined_result() {

        // An unbounded range has no meaningful fraction: `inf / inf` is NaN, and

        // the widget must treat that as "pin the thumb", not as a panic.

        assert!(value_to_fraction(0.0, f32::NEG_INFINITY, f32::INFINITY).is_nan());

        assert!(value_to_fraction(-50.0, f32::NEG_INFINITY, 0.0).is_nan());

        // A half-open range collapses every finite value onto the closed end.

        assert_eq!(value_to_fraction(50.0, 0.0, f32::INFINITY), 0.0);

        // An infinite *value* inside a finite range saturates instead of wrapping.

        assert_eq!(value_to_fraction(f32::INFINITY, 0.0, 100.0), 1.0);

        assert_eq!(value_to_fraction(f32::NEG_INFINITY, 0.0, 100.0), 0.0);

    }

    #[test]

    fn value_to_fraction_survives_a_range_whose_width_overflows_f32() {

        // `f32::MAX - f32::MIN` overflows to +inf, so the fraction degenerates:

        // every finite value divides down to 0.0 (the thumb pins left instead of

        // tracking the value) and the very top of the range becomes inf/inf =

        // NaN. Neither escapes [0, 1] and neither panics — downstream both park

        // the thumb at the left end, because a NaN margin casts to 0.

        for value in [f32::MIN, -1.0e30, 0.0, 1.0e30] {

            assert_eq!(

                value_to_fraction(value, f32::MIN, f32::MAX),

                0.0,

                "an f32-wide range should collapse {value} onto the left end",

            );

        }

        assert!(value_to_fraction(f32::MAX, f32::MIN, f32::MAX).is_nan());

        assert_eq!(margin_left(&build_thumb_style(f32::NAN)), Some(0.0));

    }

    #[test]

    fn value_to_fraction_is_pure() {

        for (min, max) in SANE_RANGES {

            for value in [min, max, 0.0, -1.0, 1.0e9] {

                let a = value_to_fraction(value, min, max);

                let b = value_to_fraction(value, min, max);

                assert!(

                    a == b || (a.is_nan() && b.is_nan()),

                    "value_to_fraction({value}, {min}, {max}) is not deterministic",

                );

            }

        }

    }

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

    // build_thumb_style  (numeric)

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

    #[test]

    fn build_thumb_style_endpoints_keep_the_thumb_inside_the_track() {

        assert_eq!(margin_left(&build_thumb_style(0.0)), Some(0.0));

        assert_eq!(margin_left(&build_thumb_style(1.0)), Some(TRAVEL));

        // The right end must leave exactly one thumb-width of room, otherwise

        // the thumb overhangs the rail it is supposed to sit on.

        assert_eq!(TRAVEL + THUMB_SIZE as f32, DESIGN_WIDTH);

    }

    #[test]

    fn build_thumb_style_rounds_to_whole_pixels() {

        // The margin is an `isize` of logical px: fractional positions must round

        // (not truncate), else the thumb drifts left by up to a pixel.

        for (fraction, expected) in [

            (0.5_f32, 92.0_f32),

            (0.25, 46.0),

            (0.75, 138.0),

            (0.1, 18.0),  // 18.4 -> 18

            (0.9, 166.0), // 165.6 -> 166

            (0.001, 0.0), // 0.184 -> 0

        ] {

            assert_eq!(

                margin_left(&build_thumb_style(fraction)),

                Some(expected),

                "fraction {fraction} landed on the wrong pixel",

            );

        }

    }

    #[test]

    fn build_thumb_style_is_monotonic_and_bounded_over_the_unit_interval() {

        let mut previous = f32::NEG_INFINITY;

        for i in 0..=1000 {

            let m = margin_left(&build_thumb_style(i as f32 / 1000.0))

                .expect("every thumb style declares a margin-left");

            assert!(m >= previous, "the thumb moved backwards at {i}/1000");

            assert!(

                (0.0..=TRAVEL).contains(&m),

                "the thumb left the rail at {i}/1000 (margin {m})",

            );

            previous = m;

        }

    }

    #[test]

    fn build_thumb_style_nan_fraction_pins_the_thumb_left_instead_of_panicking() {

        // `NaN as isize` saturates to 0 in Rust (it has been a defined saturating

        // cast since 1.45, not UB), so a NaN value/bound leaves the thumb parked

        // at the left end rather than at a garbage offset.

        assert_eq!(margin_left(&build_thumb_style(f32::NAN)), Some(0.0));

    }

    #[test]

    fn build_thumb_style_negative_and_signed_zero_fractions_are_deterministic() {

        assert_eq!(margin_left(&build_thumb_style(-0.0)), Some(0.0));

        assert_eq!(margin_left(&build_thumb_style(-1.0)), Some(-TRAVEL));

        assert_eq!(margin_left(&build_thumb_style(-0.5)), Some(-92.0));

    }

    #[test]

    fn build_thumb_style_declares_the_full_thumb_geometry_exactly_once() {

        let props = properties(&build_thumb_style(0.5));

        assert_eq!(props.len(), 9, "the thumb style changed shape: {props:?}");

        let mut seen = Vec::new();

        for p in &props {

            let d = discriminant(p);

            assert!(!seen.contains(&d), "the thumb style declares {p:?} twice");

            seen.push(d);

        }

        // A duplicate declaration would silently let the later one win; a missing

        // margin-left would freeze the thumb at the left end forever.

        assert!(

            matches!(props.last(), Some(CssProperty::MarginLeft(_))),

            "margin-left must be the last (position-dependent) declaration",

        );

    }

    #[test]

    fn build_thumb_style_geometry_is_absolute_px_and_independent_of_the_fraction() {

        for fraction in REACHABLE_FRACTIONS {

            let v = build_thumb_style(fraction);

            assert_eq!(width_px(&v), Some(THUMB_SIZE as f32), "fraction {fraction}");

            assert_eq!(height_px(&v), Some(THUMB_SIZE as f32), "fraction {fraction}");

            assert_eq!(background(&v), Some(THUMB_COLOR), "fraction {fraction}");

        }

    }

    #[test]

    fn build_thumb_style_only_the_margin_depends_on_the_fraction() {

        // Everything but `margin-left` must be byte-identical across fractions —

        // otherwise dragging the thumb would restyle the whole knob every frame.

        let strip = |f: f32| -> Vec<CssProperty> {

            properties(&build_thumb_style(f))

                .into_iter()

                .filter(|p| !matches!(p, CssProperty::MarginLeft(_)))

                .collect()

        };

        let reference = strip(0.0);

        for fraction in REACHABLE_FRACTIONS {

            assert_eq!(strip(fraction), reference, "fraction {fraction} restyled the thumb");

        }

    }

    #[test]

    fn build_thumb_style_is_pure_for_every_reachable_fraction() {

        for fraction in REACHABLE_FRACTIONS {

            assert_eq!(

                build_thumb_style(fraction),

                build_thumb_style(fraction),

                "build_thumb_style({fraction}) is not deterministic",

            );

        }

    }

    #[test]

    fn build_thumb_style_handles_every_fraction_value_to_fraction_can_produce() {

        // The full reachable domain, end to end: nothing here may panic and the

        // thumb may never leave the rail.

        for fraction in REACHABLE_FRACTIONS {

            let m = margin_left(&build_thumb_style(fraction))

                .expect("every thumb style declares a margin-left");

            assert!(

                (0.0..=TRAVEL).contains(&m),

                "fraction {fraction} put the thumb at {m}, off a {TRAVEL}px rail",

            );

        }

    }

    #[test]

    fn build_thumb_style_out_of_contract_fractions_must_not_panic() {

        // `build_thumb_style` takes a bare `f32` with no guard. Its only caller

        // feeds it `value_to_fraction`'s clamped output, so these are currently

        // unreachable — but the margin is encoded as `isize * 1000`

        // (`FloatValue::const_new`), so any |fraction| above ~5e13 overflows that

        // multiply and *panics* in an overflow-checked build instead of

        // saturating. A clamp inside `build_thumb_style` (or a saturating

        // `const_px`) would make the helper safe on its own terms.

        let hostile: [f32; 6] = [

            1.0e14,

            -1.0e14,

            1.0e30,

            f32::MAX,

            f32::INFINITY,

            f32::NEG_INFINITY,

        ];

        let panicked: Vec<f32> = hostile

            .iter()

            .copied()

            .filter(|&f| catch_unwind(AssertUnwindSafe(|| build_thumb_style(f))).is_err())

            .collect();

        assert!(

            panicked.is_empty(),

            "build_thumb_style overflows the isize fixed-point encoding and panics \

             instead of saturating for: {panicked:?}",

        );

    }

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

    // Slider::create  (numeric)

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

    #[test]

    fn create_clamps_the_value_into_the_range() {

        assert_eq!(Slider::create(150.0, 0.0, 100.0).slider_state.inner.value, 100.0);

        assert_eq!(Slider::create(-50.0, 0.0, 100.0).slider_state.inner.value, 0.0);

        assert_eq!(Slider::create(50.0, 0.0, 100.0).slider_state.inner.value, 50.0);

        assert_eq!(Slider::create(f32::MAX, -1.0, 1.0).slider_state.inner.value, 1.0);

        assert_eq!(Slider::create(f32::MIN, -1.0, 1.0).slider_state.inner.value, -1.0);

    }

    #[test]

    fn create_stores_the_bounds_verbatim() {

        for (min, max) in SANE_RANGES {

            let s = Slider::create(min, min, max);

            assert_eq!(s.slider_state.inner.min, min, "min was rewritten");

            assert_eq!(s.slider_state.inner.max, max, "max was rewritten");

        }

    }

    #[test]

    fn create_places_the_thumb_where_the_pure_helpers_say_it_belongs() {

        // The composition `create -> value_to_fraction -> build_thumb_style` is

        // the whole widget: a mismatch means the rendered thumb and the stored

        // value disagree.

        for (min, max) in SANE_RANGES {

            for value in [min, max, (min + max) / 2.0, min - 1.0, max + 1.0, 0.0] {

                let s = Slider::create(value, min, max);

                let expected =

                    margin_left(&build_thumb_style(value_to_fraction(value.clamp(min, max), min, max)));

                assert_eq!(

                    margin_left(&s.thumb_style),

                    expected,

                    "create({value}, {min}, {max}) put the thumb in the wrong place",

                );

            }

        }

    }

    #[test]

    fn create_leaves_the_thumb_on_the_rail_for_every_sane_range() {

        for (min, max) in SANE_RANGES {

            for value in [min, max, (min + max) / 2.0, min - 1.0e9, max + 1.0e9] {

                let m = thumb_margin(&Slider::create(value, min, max));

                assert!(

                    (0.0..=TRAVEL).contains(&m),

                    "create({value}, {min}, {max}) parked the thumb at {m}",

                );

            }

        }

    }

    #[test]

    fn create_with_a_zero_width_range_pins_the_thumb_left() {

        for bound in [0.0_f32, 5.0, -5.0, 1.0e9] {

            let s = Slider::create(bound, bound, bound);

            assert_eq!(s.slider_state.inner.value, bound);

            assert_eq!(thumb_margin(&s), 0.0, "a [{bound}, {bound}] range must pin left");

        }

    }

    #[test]

    fn create_with_a_nan_value_keeps_the_nan_but_still_parks_the_thumb() {

        // `f32::clamp` only asserts on its bounds, so a NaN *value* passes

        // straight through — and the NaN fraction has to degrade to a 0 margin

        // rather than an arbitrary offset.

        let s = Slider::create(f32::NAN, 0.0, 100.0);

        assert!(s.slider_state.inner.value.is_nan(), "the NaN value was silently rewritten");

        assert_eq!(thumb_margin(&s), 0.0);

    }

    #[test]

    fn create_with_infinite_bounds_does_not_panic() {

        // `min <= max` holds for these, so `clamp` is happy; the fraction is NaN

        // (inf / inf) and must degrade to a parked thumb.

        for (value, min, max) in [

            (0.0_f32, f32::NEG_INFINITY, f32::INFINITY),

            (f32::INFINITY, 0.0, f32::INFINITY),

            (f32::NEG_INFINITY, f32::NEG_INFINITY, 0.0),

            (50.0, 0.0, f32::INFINITY),

        ] {

            let s = Slider::create(value, min, max);

            let m = thumb_margin(&s);

            assert!(

                m.is_finite() && (0.0..=TRAVEL).contains(&m),

                "create({value}, {min}, {max}) put the thumb at {m}",

            );

        }

    }

    #[test]

    fn create_with_a_degenerate_range_must_not_panic() {

        // `create` runs `value.clamp(min, max)`, and `f32::clamp` **panics**

        // unless `min <= max` — a NaN bound fails that too. `min`/`max` are `pub`

        // fields on a `#[repr(C)]` struct that crosses the C/FFI boundary, so

        // nothing stops a caller from asking for an inverted or NaN-bounded

        // slider, and a panic here takes the whole app with it. Normalising the

        // range (swap, or fall back to the default) would be safe; unwinding is

        // not. Note `apply_cursor_value` already tolerates these ranges — only

        // the constructor and `set_value` do not.

        let panicked: Vec<(f32, f32)> = DEGENERATE_RANGES

            .iter()

            .copied()

            .filter(|&(min, max)| {

                catch_unwind(AssertUnwindSafe(|| Slider::create(0.0, min, max))).is_err()

            })

            .collect();

        assert!(

            panicked.is_empty(),

            "Slider::create panics (f32::clamp asserts min <= max) instead of \

             normalising these ranges: {panicked:?}",

        );

    }

    #[test]

    fn create_is_deterministic_and_distinguishes_distinct_values() {

        for (min, max) in SANE_RANGES {

            assert_eq!(Slider::create(min, min, max), Slider::create(min, min, max));

        }

        assert_ne!(Slider::create(0.0, 0.0, 100.0), Slider::create(100.0, 0.0, 100.0));

        // Same value, different range: the states differ even though the thumb

        // ends up in the same place.

        assert_ne!(Slider::create(0.0, 0.0, 100.0), Slider::create(0.0, 0.0, 200.0));

    }

    #[test]

    fn create_installs_no_hook_and_starts_undragged() {

        let s = Slider::create(50.0, 0.0, 100.0);

        assert!(

            s.slider_state.on_value_change.as_ref().is_none(),

            "create invented a value-change hook out of nowhere",

        );

        assert!(!s.slider_state.dragging, "a fresh slider must not be mid-drag");

    }

    #[test]