//! Spinner / activity-indicator widget — a small indeterminate "busy" ring. A

//! stateless single styled node (a near-clone of the leaf-node construction of

//! [`crate::widgets::badge::Badge`] / [`crate::widgets::progressbar::ProgressBar`]),

//! drawn as a circular ring whose three sides use a faint "track" colour and

//! whose top side uses a solid accent colour — the classic spinner look frozen

//! mid-rotation.

//!

//! ## PARTIAL — STATIC ONLY (no spin animation). See `TODO2` below.

//!

//! TODO2: this spinner is **static** — it shows the indeterminate ring shape but

//! does NOT rotate. Azul has no declarative CSS animation: there is no

//! `@keyframes` / `animation` / `transition` CSS property (`css/src/props` only

//! exposes one-shot `Transform`/`TransformOrigin` GPU props and the system-level

//! `AnimationMetrics` toggle; `props/basic/animation.rs` is SVG-curve

//! interpolation maths, not a style-driven keyframe engine). Producing real

//! motion would require a timer-driven `Update` loop that re-issues a rotating

//! `CssProperty::Transform` each tick (the same mechanism scroll-smoothing uses),

//! driven from the host app — there is no widget-local way to start such a timer

//! at DOM-build time. Rather than fake motion that cannot be produced, the ring

//! is rendered statically; a future revision can add the timer-driven rotation

//! once a widget-owned animation hook exists. (Compile-verified; not GUI-verified.)

//!

//! Key types: [`Spinner`].

use azul_core::dom::{Dom, IdOrClass, IdOrClass::Class, IdOrClassVec};

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

use azul_css::{

    props::{

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

        layout::{LayoutAlignSelf, LayoutFlexGrow, LayoutWidth, LayoutHeight},

        property::{CssProperty, *},

        style::{LayoutBorderTopWidth, LayoutBorderBottomWidth, LayoutBorderLeftWidth, LayoutBorderRightWidth, StyleBorderTopStyle, BorderStyle, StyleBorderBottomStyle, StyleBorderLeftStyle, StyleBorderRightStyle, StyleBorderTopColor, StyleBorderBottomColor, StyleBorderLeftColor, StyleBorderRightColor, StyleBorderTopLeftRadius, StyleBorderTopRightRadius, StyleBorderBottomLeftRadius, StyleBorderBottomRightRadius},

    },

    AzString,

};

static SPINNER_CLASS: &[IdOrClass] = &[Class(AzString::from_const_str("__azul-native-spinner"))];

/// Default ring diameter, in logical px.

const DEFAULT_SIZE: isize = 24;

/// Faint "track" colour for the three inactive sides (#d0d4d9).

const DEFAULT_TRACK_COLOR: ColorU = ColorU { r: 208, g: 212, b: 217, a: 255 };

/// Solid accent colour for the active (top) arc (#0d6efd, accent blue).

const DEFAULT_ACCENT_COLOR: ColorU = ColorU { r: 13, g: 110, b: 253, a: 255 };

/// An indeterminate busy-indicator ring. Stateless; renders a single styled

/// node. **Static** — the ring shows the spinner shape but does not rotate

/// (see the module-level `TODO2`).

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

#[repr(C)]

pub struct Spinner {

    /// The ring diameter, in logical px.

    pub size: isize,

    /// Colour of the active (top) arc.

    pub color: ColorU,

    /// Colour of the three inactive ("track") sides.

    pub track_color: ColorU,

    /// The computed inline style for the ring.

    pub spinner_style: CssPropertyWithConditionsVec,

}

/// Builds the ring style for the given diameter and colours. All three are

/// instance-dependent, so the style is built at runtime per the recipe's

/// "runtime vec when param-dependent" path (see `badge::build_badge_style`).

    // Ring thickness scales with the diameter (min 2px); radius = size/2 → circle.

        // Hug its own size inside a flex parent rather than stretch/grow.

            0,

        ))),

        // border: <border_width>px solid — three sides track, top accent.

        )),

        )),

        )),

        )),

        )),

        )),

        // top = accent (the visible "arc"); other three = faint track.

        )),

        )),

        // border-radius: size/2 → a circle.

        )),

        )),

        )),

        )),

    ])

impl Spinner {

    /// Creates a new spinner with the default size (24px) and accent colour.

    #[inline]

    /// Creates a new spinner with the given diameter (logical px) and the

    /// default colours.

    #[inline]

    /// Sets the ring diameter (logical px), recomputing the style.

    #[inline]

    /// Builder-style setter for the ring diameter.

    #[inline]

    /// Sets the active-arc colour, recomputing the style.

    #[inline]

    /// Builder-style setter for the active-arc colour.

    #[inline]

    /// Sets the inactive "track" colour, recomputing the style.

    #[inline]

    /// Builder-style setter for the inactive "track" colour.

    #[inline]

    /// Replaces `self` with a default spinner and returns the original.

    #[inline]

    /// Converts this spinner into a single DOM node with the

    /// `__azul-native-spinner` class.

    #[inline]

}

impl Default for Spinner {

}

impl From<Spinner> for Dom {

}

#[cfg(test)]

#[allow(

    clippy::too_many_lines,

    clippy::unreadable_literal,

    clippy::cast_possible_truncation,

    clippy::cast_precision_loss,

    clippy::float_cmp

)]

mod autotest_generated {

    use azul_core::dom::NodeType;

    use super::*;

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

    // Helpers

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

    /// The number of declarations `build_spinner_style` is supposed to emit.

    const DECLARATIONS: usize = 20;

    /// Every property the ring declares, in source order. A missing side (or a

    /// side declared twice) is the difference between a ring and a solid box.

    const EXPECTED_ORDER: [CssPropertyType; DECLARATIONS] = [

        CssPropertyType::AlignSelf,

        CssPropertyType::FlexGrow,

        CssPropertyType::Width,

        CssPropertyType::Height,

        CssPropertyType::BorderTopWidth,

        CssPropertyType::BorderBottomWidth,

        CssPropertyType::BorderLeftWidth,

        CssPropertyType::BorderRightWidth,

        CssPropertyType::BorderTopStyle,

        CssPropertyType::BorderBottomStyle,

        CssPropertyType::BorderLeftStyle,

        CssPropertyType::BorderRightStyle,

        CssPropertyType::BorderTopColor,

        CssPropertyType::BorderBottomColor,

        CssPropertyType::BorderLeftColor,

        CssPropertyType::BorderRightColor,

        CssPropertyType::BorderTopLeftRadius,

        CssPropertyType::BorderTopRightRadius,

        CssPropertyType::BorderBottomLeftRadius,

        CssPropertyType::BorderBottomRightRadius,

    ];

    /// `FloatValue` stores `value * FP_PRECISION_MULTIPLIER` as an `isize`, so a

    /// whole-pixel size only survives while `|size| <= isize::MAX / 1000`.

    const FP_SCALE: isize = 1000;

    /// The largest / smallest diameters that still fit the fixed-point encoding.

    /// `isize::MIN / 1000` truncates toward zero, so it scales back to

    /// `-9223372036854775000`, one step inside `isize::MIN`.

    const MAX_ENCODABLE_SIZE: isize = isize::MAX / FP_SCALE;

    const MIN_ENCODABLE_SIZE: isize = isize::MIN / FP_SCALE;

    /// Diameters that must all build a style without panicking: the degenerate

    /// small ones (where the 2px floor is thicker than the box), the ordinary

    /// ones, negatives (nothing in the widget rejects them), and both ends of

    /// the encodable range.

    const SAFE_SIZES: [isize; 16] = [

        0,

        1,

        2,

        3,

        4,

        7,

        8,

        15,

        16,

        24,

        1_000,

        -1,

        -3,

        -24,

        MAX_ENCODABLE_SIZE,

        MIN_ENCODABLE_SIZE,

    ];

    /// Colours that are trivially distinguishable in a failure message, plus the

    /// fully transparent one (alpha is carried untouched, so it must survive).

    const RED: ColorU = ColorU { r: 255, g: 0, b: 0, a: 255 };

    const GREEN: ColorU = ColorU { r: 0, g: 255, b: 0, a: 255 };

    const GHOST: ColorU = ColorU { r: 0, g: 0, b: 0, a: 0 };

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

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

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

    }

    /// The first property matching `f`, or `None` if the style never declares it.

    fn find<T>(v: &CssPropertyWithConditionsVec, f: impl Fn(&CssProperty) -> Option<T>) -> Option<T> {

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

    }

    /// The raw fixed-point encoding of a length — the value that actually

    /// survives, without a second lossy round trip through `get()`.

    fn raw(pv: PixelValue) -> isize {

        pv.number.number()

    }

    fn width(v: &CssPropertyWithConditionsVec) -> PixelValue {

        find(v, |p| match p {

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

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

                other => panic!("the ring must size in absolute lengths, got {other:?}"),

            },

            _ => None,

        })

        .expect("the ring must declare a width")

    }

    fn height(v: &CssPropertyWithConditionsVec) -> PixelValue {

        find(v, |p| match p {

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

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

                other => panic!("the ring must size in absolute lengths, got {other:?}"),

            },

            _ => None,

        })

        .expect("the ring must declare a height")

    }

    /// Border widths in `[top, right, bottom, left]` order.

    fn border_widths(v: &CssPropertyWithConditionsVec) -> [PixelValue; 4] {

        [

            find(v, |p| match p {

                CssProperty::BorderTopWidth(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::BorderRightWidth(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::BorderBottomWidth(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::BorderLeftWidth(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

        ]

        .map(|o| o.expect("the ring must declare all four border widths"))

    }

    /// Border colours in `[top, right, bottom, left]` order.

    fn border_colors(v: &CssPropertyWithConditionsVec) -> [ColorU; 4] {

        [

            find(v, |p| match p {

                CssProperty::BorderTopColor(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::BorderRightColor(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::BorderBottomColor(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::BorderLeftColor(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

        ]

        .map(|o| o.expect("the ring must declare all four border colours"))

    }

    /// Border styles in `[top, right, bottom, left]` order.

    fn border_styles(v: &CssPropertyWithConditionsVec) -> [BorderStyle; 4] {

        [

            find(v, |p| match p {

                CssProperty::BorderTopStyle(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::BorderRightStyle(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::BorderBottomStyle(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::BorderLeftStyle(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

        ]

        .map(|o| o.expect("the ring must declare all four border styles"))

    }

    /// Corner radii in `[top-left, top-right, bottom-left, bottom-right]` order.

    fn radii(v: &CssPropertyWithConditionsVec) -> [PixelValue; 4] {

        [

            find(v, |p| match p {

                CssProperty::BorderTopLeftRadius(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::BorderTopRightRadius(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::BorderBottomLeftRadius(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

            find(v, |p| match p {

                CssProperty::BorderBottomRightRadius(x) => x.get_property().map(|x| x.inner),

                _ => None,

            }),

        ]

        .map(|o| o.expect("the ring must declare all four corner radii"))

    }

    /// Every absolute length the style declares — width, height, the four border

    /// widths and the four radii.

    fn lengths(v: &CssPropertyWithConditionsVec) -> Vec<PixelValue> {

        let mut out = vec![width(v), height(v)];

        out.extend(border_widths(v));

        out.extend(radii(v));

        out

    }

    /// The properties a built DOM node carries inline, in declaration order.

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

        dom.root

            .style

            .iter_inline_properties()

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

            .collect()

    }

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

    }

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

    // build_spinner_style — shape of the emitted style

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

    #[test]

    fn build_spinner_style_declares_every_side_exactly_once() {

        // A ring is four independently-declared sides. A dropped or duplicated

        // declaration silently turns the spinner into a box (or a solid disc).

        for size in SAFE_SIZES {

            let style = build_spinner_style(size, RED, GREEN);

            let types: Vec<CssPropertyType> =

                props(&style).iter().map(CssProperty::get_type).collect();

            assert_eq!(style.len(), DECLARATIONS, "declaration count changed for {size}");

            assert_eq!(types, EXPECTED_ORDER.to_vec(), "declaration order changed for {size}");

            let mut sorted = types.clone();

            sorted.sort_unstable();

            sorted.dedup();

            assert_eq!(sorted.len(), DECLARATIONS, "a property is declared twice for {size}");

        }

    }

    #[test]

    fn build_spinner_style_declarations_are_all_unconditional() {

        // `simple()` means "no @media/@os/:hover guard". A condition sneaking in

        // would make the ring vanish on some platforms only.

        let style = build_spinner_style(24, RED, GREEN);

        for p in style.as_slice() {

            assert!(

                p.apply_if.is_empty(),

                "{:?} became conditional: {:?}",

                p.property.get_type(),

                p.apply_if,

            );

        }

    }

    #[test]

    fn build_spinner_style_is_deterministic() {

        for size in SAFE_SIZES {

            assert_eq!(

                build_spinner_style(size, RED, GREEN),

                build_spinner_style(size, RED, GREEN),

                "two identical calls produced different styles for {size}",

            );

        }

    }

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

    // build_spinner_style — numeric edges

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

    #[test]

    fn build_spinner_style_at_zero_size() {

        // 0 / 8 = 0, so the `.max(2)` floor is what keeps the border declarable;

        // the radius collapses to 0 and the box to 0x0.

        let style = build_spinner_style(0, RED, GREEN);

        assert_eq!(raw(width(&style)), 0);

        assert_eq!(raw(height(&style)), 0);

        for bw in border_widths(&style) {

            assert_eq!(raw(bw), 2 * FP_SCALE, "the 2px border floor stopped applying at size 0");

        }

        for r in radii(&style) {

            assert_eq!(raw(r), 0, "a zero-diameter ring must have a zero radius");

        }

    }

    #[test]

    fn border_width_is_an_eighth_of_the_size_with_a_two_px_floor() {

        // `(size / 8).max(2)`: integer division truncates toward zero, and every

        // negative eighth is swallowed by the floor.

        for size in (-256_isize..=256).chain(SAFE_SIZES) {

            let style = build_spinner_style(size, RED, GREEN);

            let expected = (size / 8).max(2);

            for bw in border_widths(&style) {

                assert_eq!(

                    raw(bw),

                    expected * FP_SCALE,

                    "border width wrong for size {size}",

                );

                assert!(raw(bw) >= 2 * FP_SCALE, "border width dropped below 2px for {size}");

            }

        }

    }

    #[test]

    fn radius_is_half_the_size_truncated_toward_zero() {

        // `size / 2` truncates, so odd diameters get a radius half a pixel short

        // of a perfect circle — deterministic, and identical on all four corners.

        for size in (-256_isize..=256).chain(SAFE_SIZES) {

            let style = build_spinner_style(size, RED, GREEN);

            let corners = radii(&style);

            for r in corners {

                assert_eq!(raw(r), (size / 2) * FP_SCALE, "radius wrong for size {size}");

            }

            assert!(

                corners.iter().all(|r| *r == corners[0]),

                "the four corners disagree for size {size}: {corners:?}",

            );

        }

    }

    #[test]

    fn negative_sizes_pass_straight_through_unclamped() {

        // Nothing rejects or clamps a negative diameter: the box and the radius

        // both go negative while the border keeps its 2px floor. Pinned because

        // it is the *only* documented behaviour — if the widget ever starts

        // clamping to 0, this flips loudly rather than silently changing layout.

        let style = build_spinner_style(-24, RED, GREEN);

        assert_eq!(raw(width(&style)), -24 * FP_SCALE);

        assert_eq!(raw(height(&style)), -24 * FP_SCALE);

        assert_eq!(raw(border_widths(&style)[0]), 2 * FP_SCALE);

        assert_eq!(raw(radii(&style)[0]), -12 * FP_SCALE);

    }

    #[test]

    fn the_ring_is_thicker_than_its_box_only_below_four_px() {

        // Below 4px the 2px-per-side floor eats more than the whole diameter, so

        // the "ring" degenerates into a filled blob. Above it, `size / 8` keeps

        // the two borders at a quarter of the box at most.

        for size in 0_isize..=64 {

            let style = build_spinner_style(size, RED, GREEN);

            let total = 2 * (raw(border_widths(&style)[0]) / FP_SCALE);

            if size >= 4 {

                assert!(total <= size, "size {size}: borders ({total}px) overflow the box");

            } else {

                assert!(total > size, "size {size}: expected the degenerate 2px-floor ring");

            }

        }

    }

    #[test]

    fn every_length_is_an_absolute_pixel() {

        // A relative unit here would resolve against the parent font or box and

        // either vanish or blow up — the ring must be self-contained.

        for size in SAFE_SIZES {

            let style = build_spinner_style(size, RED, GREEN);

            for length in lengths(&style) {

                assert_eq!(

                    length.metric,

                    SizeMetric::Px,

                    "size {size} produced a relative length: {length:?}",

                );

            }

        }

    }

    #[test]

    fn size_round_trips_through_the_fixed_point_encoding() {

        // encode == decode: the diameter goes in as an `isize` and must come back

        // out of the style unchanged, including at both ends of the range.

        for size in SAFE_SIZES {

            let style = build_spinner_style(size, RED, GREEN);

            assert_eq!(raw(width(&style)), size * FP_SCALE, "width encoding lost {size}");

            assert_eq!(raw(width(&style)) / FP_SCALE, size, "width did not round-trip for {size}");

            assert_eq!(raw(height(&style)) / FP_SCALE, size, "height did not round-trip for {size}");

            // The `f32` view is only exact for values a float can hold.

            if size.abs() <= 1_000 {

                assert_eq!(

                    width(&style).number.get(),

                    size as f32,

                    "float view wrong for {size}",

                );

            }

        }

    }

    #[test]

    fn the_edges_of_the_encodable_range_do_not_overflow() {

        // `isize::MAX / 1000` is the largest whole-pixel diameter `const_px` can

        // scale without wrapping; one more is the overflow pinned below.

        for size in [MAX_ENCODABLE_SIZE, MIN_ENCODABLE_SIZE] {

            let style = build_spinner_style(size, RED, GREEN);

            assert_eq!(style.len(), DECLARATIONS);

            assert_eq!(raw(width(&style)), size * FP_SCALE);

            assert_eq!(raw(radii(&style)[0]), (size / 2) * FP_SCALE);

            assert_eq!(raw(border_widths(&style)[0]), (size / 8).max(2) * FP_SCALE);

        }

    }

    #[cfg(panic = "unwind")]

    #[test]

    fn sizes_beyond_the_encodable_range_are_not_saturated() {

        use std::{

            hint::black_box,

            panic::{catch_unwind, AssertUnwindSafe},

        };

        // LATENT BUG, pinned: `PixelValue::const_px` multiplies by 1000 with a

        // plain `*`, so any diameter above `isize::MAX / 1000` (~9.2e15) either

        // panics (overflow checks on: `Spinner::with_size(isize::MAX)` kills a

        // debug build) or wraps to a garbage length (checks off) — it never

        // saturates. Asserted against a probe of the *current* profile so the

        // test is profile-independent; adding saturation flips it loudly.

        let profile_traps_overflow = catch_unwind(AssertUnwindSafe(|| {

            let big = black_box(isize::MAX);

            let _ = black_box(big * FP_SCALE);

        }))

        .is_err();

        for size in [isize::MAX, isize::MIN, MAX_ENCODABLE_SIZE + 1, MIN_ENCODABLE_SIZE - 1] {

            let widget_panicked =

                catch_unwind(AssertUnwindSafe(|| drop(build_spinner_style(size, RED, GREEN))))

                    .is_err();

            assert_eq!(

                widget_panicked, profile_traps_overflow,

                "size {size}: the fixed-point encoding no longer behaves like a raw \

                 multiply (expected panic == {profile_traps_overflow})",

            );

        }

    }

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

    // build_spinner_style — colour placement

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

    #[test]

    fn only_the_top_side_gets_the_accent_colour() {

        // The whole spinner illusion is "one lit side, three faint ones". Swapping

        // a side would render a static ring with no visible arc.

        for (color, track) in [

            (RED, GREEN),

            (GHOST, RED),

            (RED, GHOST),

            (RED, RED),

            (ColorU { r: 0, g: 0, b: 0, a: 0 }, ColorU { r: 255, g: 255, b: 255, a: 255 }),

        ] {

            let style = build_spinner_style(24, color, track);

            let [top, right, bottom, left] = border_colors(&style);

            assert_eq!(top, color, "the top side lost the accent colour");

            assert_eq!([right, bottom, left], [track; 3], "a track side lost its colour");

        }

    }

    #[test]

    fn colour_channels_survive_untouched() {

        // Alpha in particular: a fully transparent accent must stay transparent

        // rather than being normalised to opaque somewhere in the pipeline.

        for a in [0_u8, 1, 127, 255] {

            let color = ColorU { r: 1, g: 2, b: 3, a };

            let track = ColorU { r: 253, g: 254, b: 255, a: 255 - a };

            let style = build_spinner_style(24, color, track);

            let [top, right, bottom, left] = border_colors(&style);

            assert_eq!((top.r, top.g, top.b, top.a), (1, 2, 3, a));

            for side in [right, bottom, left] {

                assert_eq!((side.r, side.g, side.b, side.a), (253, 254, 255, 255 - a));

            }

        }

    }

    #[test]

    fn all_four_sides_are_solid() {

        // `BorderStyle::None` on any side would delete that quarter of the ring.

        for size in SAFE_SIZES {

            assert_eq!(

                border_styles(&build_spinner_style(size, RED, GREEN)),

                [BorderStyle::Solid; 4],

                "a side stopped being solid at size {size}",

            );

        }

    }

    #[test]

    fn the_ring_neither_grows_nor_stretches() {

        // `align-self: start` + `flex-grow: 0` are what stop a flex parent from

        // stretching the ring into an ellipse.

        let style = build_spinner_style(24, RED, GREEN);

        let align = find(&style, |p| match p {

            CssProperty::AlignSelf(x) => x.get_property().copied(),

            _ => None,

        });

        let grow = find(&style, |p| match p {

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

            _ => None,

        });

        assert_eq!(align, Some(LayoutAlignSelf::Start));

        assert_eq!(grow.map(|g| g.number()), Some(0));

    }

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

    // create / with_size / Default — construction invariants

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

    #[test]

    fn create_matches_the_documented_defaults() {

        let s = Spinner::create();

        assert_eq!(s.size, DEFAULT_SIZE);

        assert_eq!(s.size, 24, "the documented default diameter changed");

        assert_eq!(s.color, ColorU { r: 13, g: 110, b: 253, a: 255 });

        assert_eq!(s.track_color, ColorU { r: 208, g: 212, b: 217, a: 255 });

        assert_eq!(

            s.spinner_style,

            build_spinner_style(DEFAULT_SIZE, DEFAULT_ACCENT_COLOR, DEFAULT_TRACK_COLOR),

        );

        // 24px → 3px border, 12px radius.

        assert_eq!(raw(border_widths(&s.spinner_style)[0]), 3 * FP_SCALE);

        assert_eq!(raw(radii(&s.spinner_style)[0]), 12 * FP_SCALE);

    }

    #[test]

    fn default_is_create() {

        assert_eq!(Spinner::default(), Spinner::create());

    }

    #[test]

    fn with_size_records_the_size_and_rebuilds_the_style() {

        for size in SAFE_SIZES {

            let s = Spinner::with_size(size);

            assert_eq!(s.size, size, "the size field does not match the argument");

            assert_eq!(s.color, DEFAULT_ACCENT_COLOR);

            assert_eq!(s.track_color, DEFAULT_TRACK_COLOR);

            assert_eq!(s.spinner_style.len(), DECLARATIONS);

            assert_eq!(

                s.spinner_style,

                build_spinner_style(size, DEFAULT_ACCENT_COLOR, DEFAULT_TRACK_COLOR),

            );

            assert_eq!(raw(width(&s.spinner_style)) / FP_SCALE, size);

        }

    }

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

    // set_size / set_color / set_track_color — no cross-clobbering

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

    #[test]

    fn set_size_keeps_the_custom_colours() {

        // `set_size` rebuilds the whole style, so it has to feed the *current*

        // colours back in — a regression here silently resets the palette.

        let mut s = Spinner::create().with_color(RED).with_track_color(GREEN);

        s.set_size(64);

        assert_eq!(s.size, 64);

        assert_eq!(s.color, RED);

        assert_eq!(s.track_color, GREEN);

        assert_eq!(border_colors(&s.spinner_style), [RED, GREEN, GREEN, GREEN]);

        assert_eq!(raw(width(&s.spinner_style)), 64 * FP_SCALE);

    }

    #[test]

    fn set_color_touches_only_the_accent() {

        let mut s = Spinner::with_size(48).with_track_color(GREEN);

        s.set_color(RED);

        assert_eq!(s.size, 48, "set_color moved the diameter");

        assert_eq!(s.track_color, GREEN, "set_color clobbered the track colour");

        assert_eq!(border_colors(&s.spinner_style), [RED, GREEN, GREEN, GREEN]);

        assert_eq!(raw(width(&s.spinner_style)), 48 * FP_SCALE);

    }

    #[test]

    fn set_track_color_touches_only_the_track() {

        let mut s = Spinner::with_size(48).with_color(RED);

        s.set_track_color(GREEN);

        assert_eq!(s.size, 48, "set_track_color moved the diameter");

        assert_eq!(s.color, RED, "set_track_color clobbered the accent colour");

        assert_eq!(border_colors(&s.spinner_style), [RED, GREEN, GREEN, GREEN]);

    }

    #[test]

    fn setters_are_idempotent_and_never_grow_the_style() {

        // The style is *replaced*, not appended to: a hundred rounds of setters

        // must leave exactly the same 20 declarations as one round.

        let mut s = Spinner::create();

        for _ in 0..100 {

            s.set_size(24);

            s.set_color(RED);

            s.set_track_color(GREEN);

        }

        let once = Spinner::with_size(24).with_color(RED).with_track_color(GREEN);

        assert_eq!(s.spinner_style.len(), DECLARATIONS, "the style vec grew");

        assert_eq!(s, once, "repeated setters diverged from a single application");

    }

    #[test]

    fn set_size_survives_every_encodable_diameter() {

        // The same spinner walked across the whole safe range: each step must

        // leave a fully-formed style, with no state left over from the previous.

        let mut s = Spinner::create().with_color(RED).with_track_color(GREEN);

        for size in SAFE_SIZES {

            s.set_size(size);

            assert_eq!(s.size, size);

            assert_eq!(s.spinner_style.len(), DECLARATIONS);

            assert_eq!(s, Spinner::with_size(size).with_color(RED).with_track_color(GREEN));

        }

    }

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

    // Builder setters mirror the mutating ones

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

    #[test]

    fn builder_setters_match_the_mutating_setters() {

        for size in SAFE_SIZES {

            let mut mutated = Spinner::create();

            mutated.set_size(size);

            assert_eq!(Spinner::create().with_spinner_size(size), mutated, "size {size}");

        }

        let mut mutated = Spinner::create();

        mutated.set_color(RED);

        assert_eq!(Spinner::create().with_color(RED), mutated);

        let mut mutated = Spinner::create();

        mutated.set_track_color(GHOST);

        assert_eq!(Spinner::create().with_track_color(GHOST), mutated);

    }

    #[test]

    fn the_builder_chain_is_order_independent() {

        // Each setter rebuilds from all three fields, so the final spinner must

        // not depend on the order the fields were set in.

        let a = Spinner::create()

            .with_spinner_size(40)

            .with_color(RED)

            .with_track_color(GREEN);

        let b = Spinner::create()

            .with_track_color(GREEN)

            .with_color(RED)

            .with_spinner_size(40);

        let c = Spinner::create()

            .with_color(RED)

            .with_spinner_size(40)

            .with_track_color(GREEN);

        assert_eq!(a, b, "setting the size last changed the result");

        assert_eq!(a, c, "interleaving the setters changed the result");

    }

    #[test]

    fn equality_distinguishes_every_field() {

        let base = Spinner::create();

        assert_ne!(base, Spinner::create().with_spinner_size(25));

        assert_ne!(base, Spinner::create().with_color(RED));

        assert_ne!(base, Spinner::create().with_track_color(RED));

        assert_eq!(base, Spinner::create().with_spinner_size(DEFAULT_SIZE));

    }

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

    // swap_with_default

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

    #[test]

    fn swap_with_default_returns_the_original_and_installs_a_default() {

        let mut s = Spinner::with_size(96).with_color(RED).with_track_color(GREEN);

        let expected = s.clone();

        let taken = s.swap_with_default();

        assert_eq!(taken, expected, "the returned spinner is not the original");

        assert_eq!(s, Spinner::create(), "the receiver is not a fresh default");

        // The returned value must own a live style, not a moved-out husk.

        assert_eq!(taken.spinner_style.len(), DECLARATIONS);

        assert_eq!(border_colors(&taken.spinner_style), [RED, GREEN, GREEN, GREEN]);

    }

    #[test]

    fn swapping_twice_leaves_a_default_both_times() {

        let mut s = Spinner::with_size(MAX_ENCODABLE_SIZE);

        let first = s.swap_with_default();

        let second = s.swap_with_default();

        assert_eq!(first.size, MAX_ENCODABLE_SIZE);

        assert_eq!(second, Spinner::create(), "the second swap did not return the default");

        assert_eq!(s, Spinner::create());

    }

    #[test]

    fn swap_on_a_default_is_observationally_a_no_op() {

        let mut s = Spinner::create();

        let taken = s.swap_with_default();

        assert_eq!(taken, Spinner::create());

        assert_eq!(s, Spinner::create());

    }

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

    // Clone / ownership — the style vec is heap memory behind a C ABI

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

    #[test]

    fn clone_deep_copies_the_style_buffer() {

        // `CssPropertyWithConditionsVec` is a raw-pointer FFI vec: a shallow clone

        // would alias one allocation into two owners and double-free it.

        let original = Spinner::with_size(32).with_color(RED);

        let copy = original.clone();

        assert_eq!(copy, original);

        assert_ne!(

            original.spinner_style.as_ptr(),

            copy.spinner_style.as_ptr(),

            "the clone shares the original's style buffer",

        );

    }

    #[test]

    fn mutating_a_clone_leaves_the_original_alone() {

        let original = Spinner::with_size(32).with_color(RED);

        let mut copy = original.clone();

        copy.set_size(8);

        copy.set_track_color(GHOST);

        assert_eq!(original.size, 32, "mutating the clone moved the original's size");

        assert_eq!(original.track_color, DEFAULT_TRACK_COLOR);

        assert_eq!(raw(width(&original.spinner_style)), 32 * FP_SCALE);

        assert_eq!(border_colors(&original.spinner_style)[0], RED);

    }

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

    // dom()

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

    #[test]

    fn dom_is_a_single_classed_div() {

        let dom = Spinner::create().dom();

        assert_eq!(*dom.root.get_node_type(), NodeType::Div);

        assert!(dom.children.as_ref().is_empty(), "the spinner must be a leaf node");

        assert_eq!(dom.estimated_total_children, 0);

        assert_eq!(dom_classes(&dom), vec!["__azul-native-spinner".to_string()]);

    }

    #[test]

    fn dom_carries_exactly_the_spinner_style() {

        // `with_css_props` turns the vec into one inline rule per declaration;

        // nothing may be dropped, reordered or made conditional on the way.

        for size in SAFE_SIZES {

            let s = Spinner::with_size(size).with_color(RED).with_track_color(GREEN);

            let expected = props(&s.spinner_style);

            let dom = s.dom();

            assert_eq!(dom_props(&dom), expected, "the DOM lost declarations for size {size}");

            assert!(

                dom.root.style.iter_inline_properties().all(|(_, c)| c.is_empty()),

                "size {size}: an inline declaration became conditional",

            );

        }

    }

    #[test]

    fn from_impl_matches_the_dom_method() {

        let s = Spinner::with_size(17).with_color(GHOST);

        assert_eq!(Dom::from(s.clone()), s.dom());

    }

    #[test]

    fn dom_is_deterministic_for_equal_inputs() {

        let a = Spinner::with_size(13).with_color(RED).with_track_color(GHOST).dom();

        let b = Spinner::with_size(13).with_color(RED).with_track_color(GHOST).dom();

        assert_eq!(a, b, "two identically-built spinners rendered differently");

    }

    #[test]

    fn dom_survives_every_encodable_size_and_colour() {

        for size in SAFE_SIZES {

            for (color, track) in [(RED, GREEN), (GHOST, GHOST)] {

                let dom = Spinner::with_size(size)

                    .with_color(color)

                    .with_track_color(track)

                    .dom();

                assert_eq!(dom_props(&dom).len(), DECLARATIONS, "shape changed for {size}");

                assert!(dom.children.as_ref().is_empty());

                assert_eq!(dom_classes(&dom).len(), 1);

            }

        }

    }

}