//! Numeric input widget that wraps `TextInput` with numeric validation.

//!

//! Exports `NumberInput`, `NumberInputState`, and callback types

//! (`NumberInputOnValueChangeCallbackType`, `NumberInputOnFocusLostCallbackType`).

//! Internally delegates to `TextInput` and validates that the entered text

//! parses as an `f32` within the configured `min`/`max` range.

use std::string::String;

use azul_core::{

    callbacks::{CoreCallbackData, Update},

    dom::Dom,

    refany::RefAny,

};

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

use azul_css::{

    dynamic_selector::CssPropertyWithConditionsVec,

    props::{

        basic::*,

        layout::*,

        property::{CssProperty, *},

        style::*,

    },

    *,

};

use crate::{

    callbacks::{Callback, CallbackInfo},

    widgets::text_input::{

        OnTextInputReturn, TextInput, TextInputOnFocusLostCallback,

        TextInputOnFocusLostCallbackType, TextInputOnTextInputCallback,

        TextInputOnTextInputCallbackType, TextInputOnVirtualKeyDownCallback,

        TextInputOnVirtualKeyDownCallbackType, TextInputState, TextInputValid,

    },

};

/// Callback type invoked when the numeric value changes.

pub type NumberInputOnValueChangeCallbackType =

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

impl_widget_callback!(

    NumberInputOnValueChange,

    OptionNumberInputOnValueChange,

    NumberInputOnValueChangeCallback,

    NumberInputOnValueChangeCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        NumberInputOnValueChangeCallback,

    info_ty:        CallbackInfo,

    return_ty:      Update,

    default_ret:    Update::DoNothing,

    invoker_static: NUMBER_INPUT_ON_VALUE_CHANGE_INVOKER,

    invoker_ty:     AzNumberInputOnValueChangeCallbackInvoker,

    thunk_fn:       az_number_input_on_value_change_callback_thunk,

    setter_fn:      AzApp_setNumberInputOnValueChangeCallbackInvoker,

    from_handle_fn: AzNumberInputOnValueChangeCallback_createFromHostHandle,

    extra_args:     [ state: NumberInputState ],

}

/// Callback type invoked when the number input loses focus.

pub type NumberInputOnFocusLostCallbackType =

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

impl_widget_callback!(

    NumberInputOnFocusLost,

    OptionNumberInputOnFocusLost,

    NumberInputOnFocusLostCallback,

    NumberInputOnFocusLostCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        NumberInputOnFocusLostCallback,

    info_ty:        CallbackInfo,

    return_ty:      Update,

    default_ret:    Update::DoNothing,

    invoker_static: NUMBER_INPUT_ON_FOCUS_LOST_INVOKER,

    invoker_ty:     AzNumberInputOnFocusLostCallbackInvoker,

    thunk_fn:       az_number_input_on_focus_lost_callback_thunk,

    setter_fn:      AzApp_setNumberInputOnFocusLostCallbackInvoker,

    from_handle_fn: AzNumberInputOnFocusLostCallback_createFromHostHandle,

    extra_args:     [ state: NumberInputState ],

}

/// A numeric input widget that wraps `TextInput` with `f32` validation.

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

#[repr(C)]

pub struct NumberInput {

    pub number_input_state: NumberInputStateWrapper,

    pub text_input: TextInput,

    pub style: CssPropertyWithConditionsVec,

}

/// Wraps `NumberInputState` together with its value-change and focus-lost callbacks.

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

#[repr(C)]

pub struct NumberInputStateWrapper {

    pub inner: NumberInputState,

    pub on_value_change: OptionNumberInputOnValueChange,

    pub on_focus_lost: OptionNumberInputOnFocusLost,

}

/// State of a `NumberInput`: the current and previous value, plus allowed range.

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

#[repr(C)]

pub struct NumberInputState {

    /// The value before the most recent change.

    pub previous: f32,

    /// The current numeric value.

    pub number: f32,

    /// Minimum allowed value (inclusive).

    pub min: f32,

    /// Maximum allowed value (inclusive).

    pub max: f32,

}

impl Default for NumberInputState {

}

impl NumberInput {

    /// Creates a new `NumberInput` with the given initial value.

    #[must_use]

    #[must_use]

    // Function called when the input has been parsed as a number

    #[must_use]

    #[must_use]

    #[must_use]

}

    };

        }

    }

/// 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 (both NaN → value untouched). `min`/`max` are `pub` fields on

/// a `#[repr(C)]` `NumberInputState` reachable across the C/FFI boundary, so a

/// caller can invert or NaN them; a panic here would unwind across that boundary.

    };

    };

        // do not re-layout the entire screen,

        // but don't handle the character

    };

        }

    };

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

#[allow(clippy::float_cmp, clippy::too_many_lines)]

mod autotest_generated {

    use std::{

        collections::BTreeMap,

        panic::{catch_unwind, AssertUnwindSafe},

        sync::{Arc, Mutex},

    };

    use azul_core::{

        dom::{DomId, DomNodeId},

        geom::OptionLogicalPosition,

        gl::OptionGlContextPtr,

        hit_test::ScrollPosition,

        refany::OptionRefAny,

        resources::RendererResources,

        styled_dom::NodeHierarchyItemId,

        window::{MonitorVec, RawWindowHandle},

    };

    use azul_css::dynamic_selector::CssPropertyWithConditions;

    use rust_fontconfig::FcFontCache;

    use super::*;

    #[cfg(feature = "icu")]

    use crate::icu::IcuLocalizerHandle;

    use crate::{

        callbacks::{CallbackChange, CallbackInfoRefData, ExternalSystemCallbacks},

        widgets::text_input::TextInputStateWrapper,

        window::LayoutWindow,

        window_state::FullWindowState,

    };

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

    // Sample values

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

    /// Every finite `f32` the widget has to survive a format/parse round-trip on:

    /// both zeros (the sign of `-0.0` is the classic casualty), both ends of the

    /// range, the smallest normal, the smallest and largest subnormals, and `2^24`

    /// — the point where `f32` stops being able to count.

    fn finite_samples() -> [f32; 16] {

        [

            0.0,

            -0.0,

            1.0,

            -1.0,

            0.5,

            -0.5,

            42.25,

            -2.5,

            0.1,

            16_777_216.0,

            f32::MIN,

            f32::MAX,

            f32::MIN_POSITIVE,

            -f32::MIN_POSITIVE,

            f32::EPSILON,

            // smallest positive subnormal (~1.4e-45); written as bits so no float

            // literal in this file is ever out of range for `f32`.

            f32::from_bits(1),

        ]

    }

    /// Strings `<f32 as FromStr>` rejects outright. None of them contains a comma, so

    /// the widget's `,` -> `.` rewrite cannot rescue any of them either.

    const MALFORMED: [&str; 26] = [

        "",             // the empty buffer: select-all + delete

        " ",            // `from_str` does not trim

        " 1",

        "1 ",

        "\t1",

        "\n",

        "abc",

        "e",

        "e5",

        "E",

        "+",

        "-",

        ".",

        "..",

        "--1",

        "1.2.3",

        "1e",

        "1e+",

        "0x10",         // hex is not float syntax

        "0b1",

        "1_000",        // Rust *literal* syntax is not *parse* syntax

        "1/2",

        "1%",

        "½",            // vulgar fraction

        "∞",            // the symbol is not the word "inf"

        "1\u{200b}0",   // zero-width space wedged between two digits

    ];

    /// Digits that are digits to a human but not to `from_str`.

    const NON_ASCII_DIGITS: [&str; 6] = [

        "١٢٣",        // Arabic-Indic

        "١٫٥",        // Arabic-Indic + the Arabic decimal separator

        "１２３",      // fullwidth

        "𝟏",          // MATHEMATICAL BOLD DIGIT ONE

        "٣.5",        // mixed script

        "Ⅻ",          // roman numeral twelve

    ];

    /// Every spelling the Rust float parser accepts, paired with the value the widget

    /// must end up storing under the default range. `inf` / `-inf` are listed with

    /// their *clamped* results — saturating them is the widget's job, not the parser's.

    const ACCEPTED: [(&str, f32); 17] = [

        ("0", 0.0),

        ("-0", -0.0),

        ("+1", 1.0),

        ("1.", 1.0),

        (".5", 0.5),

        ("-.5", -0.5),

        ("1e3", 1000.0),

        ("1E3", 1000.0),

        ("1e+3", 1000.0),

        ("1e-3", 0.001),

        ("00042.2500", 42.25),

        ("inf", f32::MAX),

        ("infinity", f32::MAX),

        ("-inf", f32::MIN),

        ("nan", f32::NAN),

        ("NaN", f32::NAN),

        ("NAN", f32::NAN),

    ];

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

    // Fixtures

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

    /// Bit-exact float comparison — `-0.0 != 0.0` here, because losing the sign of a

    /// zero is exactly the kind of round-trip damage these tests are looking for.

    /// NaNs compare equal to each other: the widget renders every NaN as `"NaN"`, so

    /// the payload and sign cannot survive anyway.

    fn same(a: f32, b: f32) -> bool {

        if a.is_nan() || b.is_nan() {

            a.is_nan() && b.is_nan()

        } else {

            a.to_bits() == b.to_bits()

        }

    }

    /// A `NumberInputStateWrapper` with no hooks: `previous` starts at `0.0` so any

    /// write to it is visible.

    fn wrapper(number: f32, min: f32, max: f32) -> NumberInputStateWrapper {

        NumberInputStateWrapper {

            inner: NumberInputState {

                previous: 0.0,

                number,

                min,

                max,

            },

            on_value_change: OptionNumberInputOnValueChange::None,

            on_focus_lost: OptionNumberInputOnFocusLost::None,

        }

    }

    /// The widget's edit buffer, built from a `&str` the way `TextInput` builds it.

    fn text_state(text: &str) -> TextInputState {

        TextInputState {

            text: text.chars().map(|c| c as u32).collect::<Vec<_>>().into(),

            ..TextInputState::default()

        }

    }

    /// An edit buffer built from *raw* `u32` code units — the buffer is a `U32Vec`,

    /// so it can hold values that are not Unicode scalars at all.

    fn raw_text_state(units: &[u32]) -> TextInputState {

        TextInputState {

            text: units.to_vec().into(),

            ..TextInputState::default()

        }

    }

    /// The state currently stored behind a `NumberInputStateWrapper` payload.

    fn read(state: &RefAny) -> NumberInputState {

        let mut state = state.clone();

        let wrapper = state

            .downcast_ref::<NumberInputStateWrapper>()

            .expect("the payload must still be a NumberInputStateWrapper");

        wrapper.inner

    }

    /// Overwrites the stored value and clears the history, so one `LayoutWindow` can

    /// serve a whole table of cases.

    fn reset(state: &RefAny, number: f32) {

        let mut state = state.clone();

        let mut wrapper = state

            .downcast_mut::<NumberInputStateWrapper>()

            .expect("the payload must still be a NumberInputStateWrapper");

        wrapper.inner.number = number;

        wrapper.inner.previous = 0.0;

    }

    /// `n` properties lifted off the default container style — an easy way to mint

    /// style vectors that are pairwise distinct without hard-coding CSS.

    fn style(n: usize) -> CssPropertyWithConditionsVec {

        let all: Vec<CssPropertyWithConditions> =

            TextInput::default().container_style.as_ref().to_vec();

        assert!(n <= all.len(), "not enough default properties to slice");

        CssPropertyWithConditionsVec::from_vec(all.into_iter().take(n).collect())

    }

    // ---- recording hooks --------------------------------------------------

    /// Records every `NumberInputState` a hook is handed, and answers with `ret`.

    struct Recorder {

        seen: Vec<NumberInputState>,

        ret: Update,

    }

    impl Recorder {

        fn new(ret: Update) -> Self {

            Self {

                seen: Vec::new(),

                ret,

            }

        }

    }

    extern "C" fn record_value_change(

        mut data: RefAny,

        _: CallbackInfo,

        state: NumberInputState,

    ) -> Update {

        let Some(mut log) = data.downcast_mut::<Recorder>() else {

            return Update::DoNothing;

        };

        log.seen.push(state);

        log.ret

    }

    // Deliberately *not* the same body as `record_value_change`: two hooks with

    // identical bodies can be folded onto one symbol, and these two have to stay

    // distinguishable.

    extern "C" fn record_focus_lost(

        mut data: RefAny,

        _: CallbackInfo,

        state: NumberInputState,

    ) -> Update {

        match data.downcast_mut::<Recorder>() {

            Some(mut log) => {

                log.seen.push(state);

                log.ret

            }

            None => Update::DoNothing,

        }

    }

    /// A user-supplied text-input hook that accepts *everything*: if `dom()` kept it,

    /// `"abc"` would come back as `TextInputValid::Yes`.

    extern "C" fn accept_everything(

        _: RefAny,

        _: CallbackInfo,

        _: TextInputState,

    ) -> OnTextInputReturn {

        OnTextInputReturn {

            update: Update::RefreshDomAllWindows,

            valid: TextInputValid::Yes,

        }

    }

    /// A user-supplied virtual-key hook with a signature no other hook here returns.

    extern "C" fn reject_everything(

        _: RefAny,

        _: CallbackInfo,

        _: TextInputState,

    ) -> OnTextInputReturn {

        OnTextInputReturn {

            update: Update::RefreshDomAllWindows,

            valid: TextInputValid::No,

        }

    }

    fn recorded(recorder: &RefAny) -> Vec<NumberInputState> {

        let mut recorder = recorder.clone();

        let log = recorder

            .downcast_ref::<Recorder>()

            .expect("the payload must still be a Recorder");

        log.seen.clone()

    }

    fn wrapper_with_value_hook(

        number: f32,

        min: f32,

        max: f32,

        recorder: &RefAny,

    ) -> NumberInputStateWrapper {

        NumberInputStateWrapper {

            on_value_change: Some(NumberInputOnValueChange {

                refany: recorder.clone(),

                callback: (record_value_change as NumberInputOnValueChangeCallbackType).into(),

            })

            .into(),

            ..wrapper(number, min, max)

        }

    }

    fn wrapper_with_focus_hook(

        number: f32,

        min: f32,

        max: f32,

        recorder: &RefAny,

    ) -> NumberInputStateWrapper {

        NumberInputStateWrapper {

            on_focus_lost: Some(NumberInputOnFocusLost {

                refany: recorder.clone(),

                callback: (record_focus_lost as NumberInputOnFocusLostCallbackType).into(),

            })

            .into(),

            ..wrapper(number, min, max)

        }

    }

    // ---- CallbackInfo harness --------------------------------------------

    /// Runs `f` with a real `CallbackInfo` over an empty `LayoutWindow`. Neither

    /// `validate_text_input` nor `on_focus_lost` queries the DOM through it — they

    /// only hand it to the user's hook — so an empty window is enough. `CallbackInfo`

    /// is `Copy`, so a whole table of cases can share one window (building one per

    /// case would dominate the runtime).

    fn with_info<R>(f: impl FnOnce(CallbackInfo) -> R) -> R {

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

            &ref_data,

            &changes,

            DomNodeId {

                dom: DomId::ROOT_ID,

                node: NodeHierarchyItemId::NONE,

            },

            OptionLogicalPosition::None,

            OptionLogicalPosition::None,

        );

        f(info)

    }

    /// One edit delivered to `validate_text_input`; returns its answer plus the state

    /// it left behind.

    fn validate_one(state: &RefAny, text: &str) -> (OnTextInputReturn, NumberInputState) {

        with_info(|info| {

            let r = validate_text_input(state.clone(), info, text_state(text));

            (r, read(state))

        })

    }

    /// One edit made of raw code units (which need not be Unicode scalars).

    fn validate_raw(state: &RefAny, units: &[u32]) -> (OnTextInputReturn, NumberInputState) {

        with_info(|info| {

            let r = validate_text_input(state.clone(), info, raw_text_state(units));

            (r, read(state))

        })

    }

    fn focus_lost(state: &RefAny, text: &str) -> Update {

        with_info(|info| on_focus_lost(state.clone(), info, text_state(text)))

    }

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

    /// Flattened child indices of `TextInput::dom()`.

    const PLACEHOLDER: usize = 0;

    const LABEL: usize = 1;

    fn dataset_of(dom: &Dom) -> RefAny {

        dom.root

            .get_dataset()

            .cloned()

            .expect("TextInput::dom must attach its state as the node's dataset")

    }

    /// The text sitting in the widget's *edit buffer*.

    fn buffer_text(dom: &Dom) -> String {

        let mut dataset = dataset_of(dom);

        let wrapper = dataset

            .downcast_ref::<TextInputStateWrapper>()

            .expect("the dataset must be a TextInputStateWrapper");

        wrapper.inner.get_text()

    }

    /// The text actually *rendered* into the label node (a styled `<p>`

    /// wrapping its bare text leaf per the label convention).

    fn displayed_text(dom: &Dom) -> String {

        let label = &dom.children.as_ref()[LABEL];

        label

            .root

            .get_node_type()

            .format()

            .or_else(|| {

                label.children.as_ref().first().and_then(|c| c.root.get_node_type().format())

            })

            .expect("the label child must wrap a text node")

    }

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

        let mut dataset = dataset_of(dom);

        let wrapper = dataset

            .downcast_ref::<TextInputStateWrapper>()

            .expect("the dataset must be a TextInputStateWrapper");

        wrapper.inner.cursor_pos

    }

    /// The `NumberInputStateWrapper` the rendered widget actually validates against —

    /// pulled out of the hook `dom()` installed, so nothing about the wiring is

    /// re-created by hand.

    fn number_state_of(dom: &Dom) -> RefAny {

        let mut dataset = dataset_of(dom);

        let wrapper = dataset

            .downcast_ref::<TextInputStateWrapper>()

            .expect("the dataset must be a TextInputStateWrapper");

        wrapper

            .on_text_input

            .as_ref()

            .expect("NumberInput::dom must install a text-input hook")

            .refany

            .clone()

    }

    /// Delivers `text` to whichever text-input hook the rendered widget registered.

    fn drive_text_input(dom: &Dom, text: &str) -> OnTextInputReturn {

        let mut dataset = dataset_of(dom);

        let hook = dataset

            .downcast_ref::<TextInputStateWrapper>()

            .expect("the dataset must be a TextInputStateWrapper")

            .on_text_input

            .as_ref()

            .expect("NumberInput::dom must install a text-input hook")

            .clone();

        with_info(|info| (hook.callback.cb)(hook.refany.clone(), info, text_state(text)))

    }

    /// Delivers a key-down to whichever virtual-key hook survived rendering, if any.

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

        let mut dataset = dataset_of(dom);

        let hook = dataset

            .downcast_ref::<TextInputStateWrapper>()

            .expect("the dataset must be a TextInputStateWrapper")

            .on_virtual_key_down

            .as_ref()

            .cloned()?;

        Some(with_info(|info| {

            (hook.callback.cb)(hook.refany.clone(), info, text_state(""))

        }))

    }

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

    // NumberInput::create — numeric limits

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

    #[test]

    fn create_zero_is_exactly_the_default_widget() {

        assert_eq!(

            NumberInput::create(0.0),

            NumberInput::default(),

            "create(0.0) must not perturb anything Default already set",

        );

    }

    #[test]

    fn create_preserves_every_sample_value_bit_exactly() {

        for v in finite_samples() {

            let state = NumberInput::create(v).number_input_state.inner;

            assert!(

                same(state.number, v),

                "create({v:?}) stored {:?}",

                state.number,

            );

            assert!(

                same(state.previous, 0.0),

                "create({v:?}) must start with no history, got previous = {:?}",

                state.previous,

            );

            assert!(

                same(state.min, f32::MIN) && same(state.max, f32::MAX),

                "create({v:?}) must leave the range wide open, got [{}, {}]",

                state.min,

                state.max,

            );

        }

    }

    #[test]

    fn create_accepts_nan_and_infinities_without_panicking() {

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

            let state = NumberInput::create(v).number_input_state.inner;

            assert!(

                same(state.number, v),

                "create({v:?}) stored {:?}",

                state.number,

            );

        }

        assert!(NumberInput::create(f32::NAN)

            .number_input_state

            .inner

            .number

            .is_nan());

    }

    #[test]

    fn create_never_clamps_its_argument() {

        // `create` is documented as "the given initial value" — it does not consult

        // min/max, so `+inf` survives even though the default `max` is `f32::MAX`.

        // Clamping is the *input* path's job (see `validate_clamps_into_range`).

        let state = NumberInput::create(f32::INFINITY).number_input_state.inner;

        assert!(

            state.number.is_infinite(),

            "create must store the value verbatim, got {}",

            state.number,

        );

        assert!(state.number > state.max, "…even outside its own range");

    }

    #[test]

    fn the_default_range_leaves_every_finite_value_untouched() {

        let d = NumberInputState::default();

        assert!(

            d.min <= d.max,

            "the default range must be non-empty — f32::clamp panics otherwise",

        );

        assert!(same(d.min, f32::MIN) && same(d.max, f32::MAX));

        assert!(same(d.number, 0.0) && same(d.previous, 0.0));

        for v in finite_samples() {

            assert!(

                same(v.clamp(d.min, d.max), v),

                "{v:?} must pass through the default range untouched",

            );

        }

    }

    #[test]

    fn number_input_state_is_a_value_type() {

        let a = NumberInputState::default();

        let mut b = a;

        b.number = 5.0;

        assert!(

            same(a.number, 0.0),

            "NumberInputState is Copy — mutating a copy must not alias the original",

        );

        assert_ne!(a, b);

    }

    #[test]

    fn a_fresh_wrapper_has_no_hooks() {

        let w = NumberInputStateWrapper::default();

        assert!(w.on_value_change.as_ref().is_none());

        assert!(w.on_focus_lost.as_ref().is_none());

        assert_eq!(w.inner, NumberInputState::default());

    }

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

    // Builders / setters — invariants

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

    #[test]

    fn with_and_set_style_pairs_are_equivalent() {

        for n in 0..4 {

            let s = style(n);

            let a = NumberInput::create(1.0).with_placeholder_style(s.clone());

            let mut b = NumberInput::create(1.0);

            b.set_placeholder_style(s.clone());

            assert_eq!(a, b, "with_placeholder_style != set_placeholder_style ({n})");

            let a = NumberInput::create(1.0).with_container_style(s.clone());

            let mut b = NumberInput::create(1.0);

            b.set_container_style(s.clone());

            assert_eq!(a, b, "with_container_style != set_container_style ({n})");

            let a = NumberInput::create(1.0).with_label_style(s.clone());

            let mut b = NumberInput::create(1.0);

            b.set_label_style(s);

            assert_eq!(a, b, "with_label_style != set_label_style ({n})");

        }

    }

    #[test]

    fn style_setters_write_to_disjoint_fields() {

        let placeholder = style(1);

        let container = style(2);

        let label = style(3);

        assert_ne!(placeholder, container, "the fixture must be distinguishable");

        assert_ne!(container, label, "the fixture must be distinguishable");

        let input = NumberInput::create(0.0)

            .with_placeholder_style(placeholder.clone())

            .with_container_style(container.clone())

            .with_label_style(label.clone());

        assert_eq!(input.text_input.placeholder_style, placeholder);

        assert_eq!(input.text_input.container_style, container);

        assert_eq!(input.text_input.label_style, label);

        assert_eq!(

            input.style,

            NumberInput::default().style,

            "NumberInput::style is not a dumping ground for the TextInput styles",

        );

    }

    #[test]

    fn with_and_set_callback_pairs_are_equivalent() {

        // The same `RefAny` handle on both sides: `RefAny` equality is identity of the

        // shared allocation, so two independent `RefAny::new(0u32)` would never match.

        let data = RefAny::new(0u32);

        let a = NumberInput::create(1.0).with_on_value_change(

            data.clone(),

            record_value_change as NumberInputOnValueChangeCallbackType,

        );

        let mut b = NumberInput::create(1.0);

        b.set_on_value_change(

            data.clone(),

            record_value_change as NumberInputOnValueChangeCallbackType,

        );

        assert_eq!(a, b, "with_on_value_change != set_on_value_change");

        let a = NumberInput::create(1.0).with_on_focus_lost(

            data.clone(),

            record_focus_lost as NumberInputOnFocusLostCallbackType,

        );

        let mut b = NumberInput::create(1.0);

        b.set_on_focus_lost(

            data.clone(),

            record_focus_lost as NumberInputOnFocusLostCallbackType,

        );

        assert_eq!(a, b, "with_on_focus_lost != set_on_focus_lost");

        let a = NumberInput::create(1.0).with_on_text_input(

            data.clone(),

            accept_everything as TextInputOnTextInputCallbackType,

        );

        let mut b = NumberInput::create(1.0);

        b.set_on_text_input(

            data.clone(),

            accept_everything as TextInputOnTextInputCallbackType,

        );

        assert_eq!(a, b, "with_on_text_input != set_on_text_input");

        let a = NumberInput::create(1.0).with_on_virtual_key_down(

            data.clone(),

            reject_everything as TextInputOnVirtualKeyDownCallbackType,

        );

        let mut b = NumberInput::create(1.0);

        b.set_on_virtual_key_down(data, reject_everything as TextInputOnVirtualKeyDownCallbackType);

        assert_eq!(a, b, "with_on_virtual_key_down != set_on_virtual_key_down");

    }

    #[test]

    fn setting_a_hook_twice_keeps_the_last_one() {

        let first = RefAny::new(1u32);

        let second = RefAny::new(2u32);

        let mut input = NumberInput::create(0.0);

        input.set_on_value_change(

            first.clone(),

            record_value_change as NumberInputOnValueChangeCallbackType,

        );

        input.set_on_value_change(

            second.clone(),

            record_value_change as NumberInputOnValueChangeCallbackType,

        );

        let stored = input

            .number_input_state

            .on_value_change

            .as_ref()

            .expect("the hook must be set");

        assert_eq!(stored.refany, second, "the last hook must win");

        assert_ne!(stored.refany, first, "the first hook must be released");

    }

    #[test]

    fn swap_with_default_hands_back_the_original_and_leaves_a_fresh_widget() {

        let data = RefAny::new(0u32);

        let mut input = NumberInput::create(7.5)

            .with_on_value_change(

                data,

                record_value_change as NumberInputOnValueChangeCallbackType,

            )

            .with_label_style(style(2));

        let original = input.clone();

        let taken = input.swap_with_default();

        assert_eq!(taken, original, "swap_with_default must return the original");

        assert_eq!(

            input,

            NumberInput::create(0.0),

            "the receiver must be left as a fresh 0.0 widget",

        );

        assert_eq!(

            input,

            NumberInput::default(),

            "…which is also exactly the Default widget",

        );

        // Idempotent on an already-defaulted receiver.

        let second = input.swap_with_default();

        assert_eq!(second, NumberInput::default());

        assert_eq!(input, NumberInput::default());

    }

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

    // NumberInput::dom — encode / decode round-trip

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

    #[test]

    fn dom_wires_the_text_input_and_parks_the_cursor_at_the_end() {

        let dom = NumberInput::create(-12.5).dom();

        assert_eq!(

            dom.children.as_ref().len(),

            2,

            "TextInput renders a placeholder node and a label node",

        );

        assert_eq!(

            dom.root.callbacks.as_ref().len(),

            5,

            "focus received/lost, text input, virtual key down, hover",

        );

        assert!(

            dom.children.as_ref()[PLACEHOLDER]

                .children

                .as_ref()

                .first()

                .and_then(|c| c.root.get_node_type().format())

                .is_some(),

            "the placeholder child must wrap a text node",

        );

        assert_eq!(buffer_text(&dom), "-12.5");

        assert_eq!(displayed_text(&dom), "-12.5");

        assert_eq!(

            cursor_pos(&dom),

            "-12.5".chars().count(),

            "the cursor must sit at the end of the rendered number",

        );

    }

    #[test]

    fn dom_text_round_trips_back_to_the_same_f32() {

        for v in finite_samples() {

            let dom = NumberInput::create(v).dom();

            let text = buffer_text(&dom);

            let parsed: f32 = text.parse().unwrap_or_else(|e| {

                panic!("the widget rendered {v:?} as {text:?}, which is not a float: {e}")

            });

            assert!(

                same(parsed, v),

                "{v:?} was rendered as {text:?} and read back as {parsed:?}",

            );

            assert_eq!(

                displayed_text(&dom),

                text,

                "the visible label and the edit buffer must agree for {v:?}",

            );

        }

    }

    #[test]

    fn dom_renders_the_shortest_round_trip_form() {

        for (value, expected) in [

            (0.0f32, "0"),

            (1.0, "1"),

            (-1.5, "-1.5"),

            (42.25, "42.25"),

            (0.5, "0.5"),

        ] {

            assert_eq!(buffer_text(&NumberInput::create(value).dom()), expected);

        }

    }

    #[test]

    fn dom_renders_non_finite_values_as_inf_and_nan() {

        assert_eq!(buffer_text(&NumberInput::create(f32::INFINITY).dom()), "inf");

        assert_eq!(

            buffer_text(&NumberInput::create(f32::NEG_INFINITY).dom()),

            "-inf",

        );

        assert_eq!(buffer_text(&NumberInput::create(f32::NAN).dom()), "NaN");

        assert_eq!(

            buffer_text(&NumberInput::create(-f32::NAN).dom()),

            "NaN",

            "the sign of a NaN is not rendered, so it cannot round-trip",

        );

    }

    #[test]

    fn every_string_the_widget_renders_is_accepted_by_its_own_validator() {

        let mut values = finite_samples().to_vec();

        values.extend_from_slice(&[f32::INFINITY, f32::NEG_INFINITY, f32::NAN]);

        for v in values {

            let text = buffer_text(&NumberInput::create(v).dom());

            let state = RefAny::new(wrapper(0.0, f32::MIN, f32::MAX));

            let (r, _) = validate_one(&state, &text);

            assert_eq!(

                r.valid,

                TextInputValid::Yes,

                "the widget renders {v:?} as {text:?} but then refuses to parse it back",

            );

        }

    }

    #[test]

    fn dom_renders_a_value_that_is_outside_its_own_range() {

        // Neither `create` nor `dom` consults min/max — only typed input is clamped.

        // A widget constructed out of range therefore *shows* a number it would never

        // accept from the keyboard.

        let mut input = NumberInput::create(1000.0);

        input.number_input_state.inner.min = 0.0;

        input.number_input_state.inner.max = 10.0;

        assert_eq!(buffer_text(&input.dom()), "1000");

    }

    #[test]

    fn dom_replaces_a_user_supplied_text_input_hook_with_the_numeric_validator() {

        // `dom()` unconditionally overwrites `on_text_input`, so a hook installed via

        // `with_on_text_input` never fires. `accept_everything` would answer `Yes` to

        // "abc"; the numeric validator answers `No`.

        let dom = NumberInput::create(1.0)

            .with_on_text_input(

                RefAny::new(0u32),

                accept_everything as TextInputOnTextInputCallbackType,

            )

            .dom();

        let r = drive_text_input(&dom, "abc");

        assert_eq!(

            r.valid,

            TextInputValid::No,

            "the numeric validator must own the text-input hook after dom()",

        );

        assert_eq!(r.update, Update::DoNothing);

    }

    #[test]

    fn dom_keeps_a_user_supplied_virtual_key_hook() {

        let dom = NumberInput::create(1.0)

            .with_on_virtual_key_down(

                RefAny::new(0u32),

                reject_everything as TextInputOnVirtualKeyDownCallbackType,

            )

            .dom();

        let r = drive_virtual_key_down(&dom)

            .expect("with_on_virtual_key_down must survive rendering");

        assert_eq!(r.update, Update::RefreshDomAllWindows);

        assert_eq!(r.valid, TextInputValid::No);

    }

    #[test]

    fn dom_wires_the_value_change_hook_through_the_rendered_widget() {

        let recorder = RefAny::new(Recorder::new(Update::RefreshDom));

        let dom = NumberInput::create(0.0)

            .with_on_value_change(

                recorder.clone(),

                record_value_change as NumberInputOnValueChangeCallbackType,

            )

            .dom();

        let r = drive_text_input(&dom, "12,5");

        assert_eq!(r.valid, TextInputValid::Yes);

        assert_eq!(

            r.update,

            Update::RefreshDom,

            "validate must return whatever the user's hook returned",

        );

        let seen = recorded(&recorder);

        assert_eq!(seen.len(), 1, "the hook must fire exactly once per edit");

        assert!(same(seen[0].number, 12.5));

        assert!(same(seen[0].previous, 0.0));

        assert!(

            same(read(&number_state_of(&dom)).number, 12.5),

            "the state behind the rendered DOM must have been updated too",

        );

    }

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

    // validate_text_input — the parser

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

    #[test]

    fn validate_rejects_malformed_input_without_touching_the_state() {

        // One state for the whole table: a rejected edit must not accumulate either.

        let state = RefAny::new(wrapper(7.5, -100.0, 100.0));

        with_info(|info| {

            for text in MALFORMED {

                let r = validate_text_input(state.clone(), info, text_state(text));

                assert_eq!(r.valid, TextInputValid::No, "{text:?} must be rejected");

                assert_eq!(

                    r.update,

                    Update::DoNothing,

                    "a rejected edit must not trigger a relayout ({text:?})",

                );

                let after = read(&state);

                assert!(

                    same(after.number, 7.5),

                    "{text:?} changed the value to {}",

                    after.number,

                );

                assert!(

                    same(after.previous, 0.0),

                    "{text:?} touched `previous` ({})",

                    after.previous,

                );

            }

        });

    }

    #[test]

    fn validate_rejects_digits_that_are_not_ascii_digits() {

        let state = RefAny::new(wrapper(3.0, f32::MIN, f32::MAX));

        with_info(|info| {

            for text in NON_ASCII_DIGITS {

                let r = validate_text_input(state.clone(), info, text_state(text));

                assert_eq!(r.valid, TextInputValid::No, "{text:?} must be rejected");

                assert!(

                    same(read(&state).number, 3.0),

                    "{text:?} must not change the value",

                );

            }

        });

    }

    #[test]

    fn validate_accepts_every_form_the_rust_float_parser_accepts() {

        let state = RefAny::new(wrapper(-1.0, f32::MIN, f32::MAX));

        with_info(|info| {

            for (text, expected) in ACCEPTED {

                reset(&state, -1.0);

                let r = validate_text_input(state.clone(), info, text_state(text));

                assert_eq!(r.valid, TextInputValid::Yes, "{text:?} must be accepted");

                assert_eq!(

                    r.update,

                    Update::DoNothing,

                    "no hook is installed, so there is nothing to redraw ({text:?})",

                );

                let after = read(&state);

                assert!(

                    same(after.number, expected),

                    "{text:?} stored {} (expected {expected})",

                    after.number,

                );

                assert!(