//! SVG geometry primitives (points, curves, rects, vectors) and animation interpolation functions.

use crate::impl_option;

/// Precision-reducing `usize` → `f64` for Bézier sample indices. The step count

/// is tiny so no precision is actually lost; `as` is the only `usize`→`f64` form,

/// isolated here behind a documented attribute.

#[inline]

#[allow(clippy::cast_precision_loss)]

/// Truncating `f64` → `f32` for SVG curve sample coordinates. Behaviour-preserving

/// (`as f32` rounds to the nearest representable value); isolates the narrowing.

#[inline]

#[allow(clippy::cast_possible_truncation)]

/// Holds context needed to resolve animation interpolation relative to parent and current rects.

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

#[repr(C)]

pub struct InterpolateResolver {

    pub interpolate_func: AnimationInterpolationFunction,

    pub parent_rect_width: f32,

    pub parent_rect_height: f32,

    pub current_rect_width: f32,

    pub current_rect_height: f32,

}

/// A 2D point with f32 coordinates, used in SVG paths and bezier curves.

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

#[repr(C)]

pub struct SvgPoint {

    pub x: f32,

    pub y: f32,

}

/// A cubic bezier curve defined by start, two control points, and end point.

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

#[repr(C)]

pub struct SvgCubicCurve {

    pub start: SvgPoint,

    pub ctrl_1: SvgPoint,

    pub ctrl_2: SvgPoint,

    pub end: SvgPoint,

}

/// Mass-spring-damper parameters for [`AnimationInterpolationFunction::Spring`].

///

/// Lives here rather than in `azul-core` because it is part of a `#[repr(C)]`

/// CSS enum that crosses the C ABI; `azul-core` re-exports it so the animation

/// engine can keep talking about `Spring` without reaching across layers.

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

#[repr(C)]

pub struct SpringCurve {

    /// Pull toward the target. Higher = faster, more eager.

    pub stiffness: f32,

    /// Resistance. Higher = less overshoot; at critical damping, none.

    pub damping: f32,

    /// Inertia. Higher = more sluggish, more overshoot for a given stiffness.

    pub mass: f32,

}

impl SpringCurve {

    /// No overshoot, quick settle. The safe default for UI motion.

    pub const SMOOTH: Self = Self {

        stiffness: 170.0,

        damping: 26.0,

        mass: 1.0,

    };

    /// Soft and slow; for large surfaces where snappiness reads as jarring.

    pub const GENTLE: Self = Self {

        stiffness: 120.0,

        damping: 20.0,

        mass: 1.0,

    };

    /// Fast with a slight overshoot; for small controls that should feel crisp.

    pub const SNAPPY: Self = Self {

        stiffness: 260.0,

        damping: 20.0,

        mass: 1.0,

    };

    /// The damping ratio: < 1 under-damped (overshoots), 1 critical, > 1 over-damped.

    #[must_use]

        } else {

        }

    /// One integration step. Returns the new `(value, velocity)`.

    ///

    /// `dt` is clamped: a stalled frame (tab restored, breakpoint hit) must not

    /// hand the integrator a huge step and fling the value off to infinity.

    #[must_use]

            // Degenerate parameters: snap rather than divide by zero.

        // Semi-implicit Euler: velocity first, then position FROM THE NEW

        // velocity. That ordering is what makes this stable where explicit

        // Euler is not. Explicit FP on purpose: mul_add is fused only with

        // +fma and changes results bit-for-bit; animation sampling must stay

        // bit-reproducible across builds. (clippy::suboptimal_flops)

        #[allow(clippy::suboptimal_flops)]

        #[allow(clippy::suboptimal_flops)]

        #[allow(clippy::suboptimal_flops)]

    /// Longest step handed to the integrator, in seconds (~3 frames at 60 Hz).

    pub const MAX_STEP_SECS: f32 = 0.05;

    /// Whether the spring has effectively arrived.

    ///

    /// Both conditions are required: near the target AND barely moving. Position

    /// alone would settle at the peak of an overshoot, mid-flight.

    #[must_use]

    /// Distance below which a spring counts as arrived (~a sixteenth of a device px).

    pub const EPSILON_VALUE: f32 = 0.06;

    /// Speed below which a spring counts as stopped, in units/second.

    pub const EPSILON_VELOCITY: f32 = 0.06;

}

impl Default for SpringCurve {

}

#[allow(variant_size_differences)]

// repr(C,u8) FFI enum: boxing the large variant would change the C ABI (api.json bindings); size

// disparity accepted

/// Represents an animation timing function.

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

#[repr(C, u8)]

pub enum AnimationInterpolationFunction {

    Ease,

    Linear,

    EaseIn,

    EaseOut,

    EaseInOut,

    CubicBezier(SvgCubicCurve),

    /// A physical spring rather than a fixed-duration curve.

    ///

    /// Unlike every other variant this one has NO duration: it runs until the

    /// mass settles. That is the point — a spring can be retargeted mid-flight

    /// while preserving position AND velocity, so an interrupted animation

    /// bends toward the new target instead of restarting from a standstill.

    /// A bezier cannot express that, which is why engine-driven layout

    /// transitions default to this.

    Spring(SpringCurve),

}

/// An axis-aligned rectangle with optional rounded corners.

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

#[repr(C)]

pub struct SvgRect {

    pub width: f32,

    pub height: f32,

    pub x: f32,

    pub y: f32,

    pub radius_top_left: f32,

    pub radius_top_right: f32,

    pub radius_bottom_left: f32,

    pub radius_bottom_right: f32,

}

/// A 2D vector with f64 coordinates, used for tangent and direction calculations.

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

#[repr(C)]

pub struct SvgVector {

    pub x: f64,

    pub y: f64,

}

/// A quadratic bezier curve defined by start, one control point, and end point.

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

#[repr(C)]

pub struct SvgQuadraticCurve {

    pub start: SvgPoint,

    pub ctrl: SvgPoint,

    pub end: SvgPoint,

}

impl_option!(

    SvgPoint,

    OptionSvgPoint,

    [Debug, Clone, PartialEq, PartialOrd]

);

impl SvgPoint {

    /// Creates a new `SvgPoint` from x and y coordinates

    #[inline]

    #[must_use]

    /// Returns the Euclidean distance between this point and `other`.

    #[inline]

    #[must_use]

}

impl SvgRect {

    /// Expands this rect to also contain `other`.

    /// Note: does not incorporate rounded edges!

    /// Origin of x and y is assumed to be the top left corner

    #[must_use]

    /// Expands the rect with a certain amount of padding

    #[must_use]

    /// Returns the center point of the rect.

    #[must_use]

}

const STEP_SIZE: usize = 20;

const STEP_SIZE_F64: f64 = 0.05;

// Bézier sampling keeps the explicit `a*b + c` forms rather than `mul_add`:

// `f32::mul_add` lowers to a software `fmaf` call (slower) on targets without

// `+fma`, and changes results bit-for-bit. (clippy::suboptimal_flops)

#[allow(clippy::suboptimal_flops)]

impl SvgCubicCurve {

    /// Creates a new `SvgCubicCurve` from start, two control points, and end point

    #[inline]

    #[must_use]

    /// Reverses the curve direction in place, swapping start/end and `ctrl_1/ctrl_2`.

    /// Returns the start point of the curve.

    #[must_use]

    /// Returns the end point of the curve.

    #[must_use]

    /// Evaluates the x coordinate of the curve at parameter `t` in [0, 1].

    #[must_use]

    /// Evaluates the y coordinate of the curve at parameter `t` in [0, 1].

    #[must_use]

    /// Returns the approximate arc length of the curve using linear sampling.

    #[must_use]

        // NOTE: this arc length parametrization is not very precise, but fast

    /// Returns the parameter `t` corresponding to a given arc-length `offset`.

    #[must_use]

        // step through the line until the offset is reached,

        // then interpolate linearly between the

        // current at the last sampled point

            // linearly interpolate between last t and current t

        }

    /// Returns the normalized tangent vector at parameter `t`.

    #[must_use]

        // 1. Calculate the derivative of the bezier curve.

        //

        // This means that we go from 4 points to 3 points and redistribute

        // the weights of the control points according to the formula:

        //

        // w'0 = 3 * (w1-w0)

        // w'1 = 3 * (w2-w1)

        // w'2 = 3 * (w3-w2)

        // The first derivative of a cubic bezier curve is a quadratic

        // bezier curve. Luckily, the first derivative is also the tangent

        // vector (slope) of the curve. So all we need to do is to sample the

        // quadratic curve at t

    /// Returns the axis-aligned bounding box of the curve's control points.

    #[must_use]

}

impl SvgVector {

    /// Returns the angle of the vector in degrees

    #[inline]

    #[must_use]

    /// Returns a unit-length vector in the same direction, or zero if the length is zero.

    #[inline]

    #[must_use = "returns a new vector"]

    /// Rotate the vector 90 degrees counter-clockwise

    #[must_use = "returns a new vector"]

    #[inline]

}

// Explicit FP math (mul_add is slower without `+fma`); see SvgCubicCurve.

#[allow(clippy::suboptimal_flops)]

impl SvgQuadraticCurve {

    /// Creates a new `SvgQuadraticCurve` from start, control, and end points

    #[inline]

    #[must_use]

    /// Reverses the curve direction in place.

    /// Returns the start point of the curve.

    #[must_use]

    /// Returns the end point of the curve.

    #[must_use]

    /// Returns the axis-aligned bounding box of the curve's control points.

    #[must_use]

    /// Evaluates the x coordinate of the curve at parameter `t` in [0, 1].

    #[must_use]

    /// Evaluates the y coordinate of the curve at parameter `t` in [0, 1].

    #[must_use]

    /// Returns the approximate arc length by converting to a cubic curve.

    #[must_use]

    /// Returns the parameter `t` corresponding to a given arc-length `offset`.

    #[must_use]

    /// Returns the normalized tangent vector at parameter `t`.

    #[must_use]

    /// Converts this quadratic curve to an equivalent cubic bezier curve.

}

impl AnimationInterpolationFunction {

    /// Returns the cubic bezier curve corresponding to this timing function.

    #[must_use]

            // A spring HAS no equivalent curve — its shape depends on the

            // velocity it carries at the moment it is sampled, which a fixed

            // curve cannot represent. `ease-in-out` is returned as the closest

            // fixed stand-in for callers that can only think in curves (CSS

            // serialisation, the SVG path preview); anything actually animating

            // a spring must integrate it instead — see

            // `azul_core::animation::Spring::step`.

        }

    /// Whether this function is a physical spring, and therefore has no

    /// duration and cannot be evaluated as a curve.

    ///

    /// Callers that own a timeline must branch on this: asking a spring for its

    /// value at `t` silently gives them an ease-in-out instead.

    #[must_use]

    /// Evaluates the interpolation function at time `t`, returning the eased value.

    ///

    /// For a spring this evaluates the ease-in-out stand-in from

    /// [`Self::get_curve`]; integrate the spring instead if you need its real

    /// trajectory.

    #[must_use]

}

#[cfg(test)]

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

mod autotest_generated {

    use super::*;

    // ---- helpers -----------------------------------------------------------

    fn approx(a: f64, b: f64, eps: f64) -> bool {

        (a - b).abs() <= eps

    }

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

        (a - b).abs() <= eps

    }

    fn p(x: f32, y: f32) -> SvgPoint {

        SvgPoint::new(x, y)

    }

    /// A curve whose control points are all exactly representable in binary f32,

    /// so endpoint evaluation is bit-exact.

    fn exact_curve() -> SvgCubicCurve {

        SvgCubicCurve::new(p(0.0, 0.0), p(0.25, 0.5), p(0.75, 0.5), p(1.0, 1.0))

    }

    /// Degenerate curve: every control point identical (zero arc length).

    fn degenerate_curve() -> SvgCubicCurve {

        SvgCubicCurve::new(p(5.0, 5.0), p(5.0, 5.0), p(5.0, 5.0), p(5.0, 5.0))

    }

    const ALL_VARIANTS: [AnimationInterpolationFunction; 5] = [

        AnimationInterpolationFunction::Ease,

        AnimationInterpolationFunction::Linear,

        AnimationInterpolationFunction::EaseIn,

        AnimationInterpolationFunction::EaseOut,

        AnimationInterpolationFunction::EaseInOut,

    ];

    /// Nasty f64 inputs fed to every `t` / `offset` parameter.

    const NASTY_F64: [f64; 12] = [

        0.0,

        -0.0,

        1.0,

        -1.0,

        2.0,

        1e-300,

        1e300,

        f64::MAX,

        f64::MIN,

        f64::INFINITY,

        f64::NEG_INFINITY,

        f64::NAN,

    ];

    // ---- 1. idx_to_f64 (numeric: zero / min_max / overflow) ----------------

    #[test]

    fn idx_to_f64_zero_and_small_values_are_exact() {

        assert_eq!(idx_to_f64(0), 0.0);

        assert_eq!(idx_to_f64(1), 1.0);

        assert_eq!(idx_to_f64(20), 20.0);

        assert_eq!(idx_to_f64(STEP_SIZE), 20.0);

    }

    #[test]

    fn idx_to_f64_is_strictly_monotonic_over_the_sampling_range() {

        for i in 0..STEP_SIZE {

            assert!(

                idx_to_f64(i + 1) > idx_to_f64(i),

                "not monotonic at i = {i}"

            );

        }

    }

    #[test]

    fn idx_to_f64_at_usize_max_does_not_panic_and_stays_finite() {

        // usize::MAX exceeds f64's 2^53 exact-integer range: the cast must round,

        // not trap. The only guarantee we rely on is "finite, positive, no panic".

        let v = idx_to_f64(usize::MAX);

        assert!(v.is_finite(), "usize::MAX must not become inf/NaN: {v}");

        assert!(v > 0.0);

        assert!(v >= idx_to_f64(STEP_SIZE));

    }

    #[test]

    fn idx_to_f64_covers_the_full_bezier_domain() {

        // The sampling loop relies on STEP_SIZE * STEP_SIZE_F64 == 1.0; if this

        // ever drifts, get_length()/get_t_at_offset() silently truncate the curve.

        assert!(approx(idx_to_f64(STEP_SIZE) * STEP_SIZE_F64, 1.0, 1e-12));

    }

    // ---- 2. f64_to_f32 (numeric: zero / negative / overflow / nan_inf) -----

    #[test]

    fn f64_to_f32_zero_preserves_sign() {

        assert_eq!(f64_to_f32(0.0), 0.0_f32);

        assert!(f64_to_f32(0.0).is_sign_positive());

        assert!(f64_to_f32(-0.0).is_sign_negative());

    }

    #[test]

    fn f64_to_f32_overflow_saturates_to_infinity_not_a_panic() {

        // f64::MAX has no f32 representation: IEEE round-to-nearest gives +-inf.

        assert_eq!(f64_to_f32(f64::MAX), f32::INFINITY);

        assert_eq!(f64_to_f32(f64::MIN), f32::NEG_INFINITY);

        assert_eq!(f64_to_f32(1e300), f32::INFINITY);

        assert_eq!(f64_to_f32(-1e300), f32::NEG_INFINITY);

    }

    #[test]

    fn f64_to_f32_underflow_flushes_to_signed_zero() {

        let tiny = f64_to_f32(1e-300);

        assert_eq!(tiny, 0.0_f32);

        assert!(tiny.is_sign_positive());

        let neg_tiny = f64_to_f32(-1e-300);

        assert_eq!(neg_tiny, 0.0_f32);

        assert!(neg_tiny.is_sign_negative(), "sign must survive underflow");

    }

    #[test]

    fn f64_to_f32_nan_and_inf_are_defined_and_do_not_panic() {

        assert!(f64_to_f32(f64::NAN).is_nan());

        assert_eq!(f64_to_f32(f64::INFINITY), f32::INFINITY);

        assert_eq!(f64_to_f32(f64::NEG_INFINITY), f32::NEG_INFINITY);

    }

    #[test]

    fn f64_to_f32_round_trips_values_that_originate_as_f32() {

        // encode == decode: every f32 widened to f64 must narrow back unchanged.

        for original in [

            0.0_f32,

            1.0,

            -1.0,

            0.25,

            0.1,

            f32::MAX,

            f32::MIN,

            f32::MIN_POSITIVE,

            f32::EPSILON,

        ] {

            assert_eq!(

                f64_to_f32(f64::from(original)),

                original,

                "round-trip failed for {original}"

            );

        }

    }

    // ---- 3. SvgPoint::new (constructor) ------------------------------------

    #[test]

    fn svg_point_new_stores_fields_verbatim_including_extremes() {

        for (x, y) in [

            (0.0_f32, 0.0_f32),

            (-1.5, 2.5),

            (f32::MAX, f32::MIN),

            (f32::MIN_POSITIVE, -f32::MIN_POSITIVE),

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

        ] {

            let pt = SvgPoint::new(x, y);

            assert_eq!(pt.x, x);

            assert_eq!(pt.y, y);

        }

        let nan_point = SvgPoint::new(f32::NAN, f32::NAN);

        assert!(nan_point.x.is_nan() && nan_point.y.is_nan());

        // NaN != NaN, so a NaN point is not even equal to itself.

        assert_ne!(nan_point, nan_point);

    }

    #[test]

    fn svg_point_default_is_the_origin() {

        assert_eq!(SvgPoint::default(), p(0.0, 0.0));

    }

    // ---- 4. SvgPoint::distance (other) -------------------------------------

    #[test]

    fn distance_basic_values_and_identity() {

        assert_eq!(p(0.0, 0.0).distance(p(3.0, 4.0)), 5.0);

        assert_eq!(p(0.0, 0.0).distance(p(0.0, 0.0)), 0.0);

        assert_eq!(p(-3.0, -4.0).distance(p(0.0, 0.0)), 5.0);

    }

    #[test]

    fn distance_is_symmetric() {

        let a = p(-12.5, 7.25);

        let b = p(3.0, -9.75);

        assert_eq!(a.distance(b), b.distance(a));

    }

    #[test]

    fn distance_overflows_to_infinity_because_the_delta_is_computed_in_f32() {

        // dx = f32::MAX - (-f32::MAX) overflows f32 *before* the f64 widening,

        // so the f64 return type cannot rescue the result. Must be inf, not a panic.

        let d = p(-f32::MAX, 0.0).distance(p(f32::MAX, 0.0));

        assert!(d.is_infinite() && d > 0.0, "expected +inf, got {d}");

    }

    #[test]

    fn distance_between_extreme_corners_never_underreports() {

        // Whatever hypotf does at the top of the f32 range, the distance must be

        // at least as large as the largest single component delta.

        let d = p(0.0, 0.0).distance(p(f32::MAX, f32::MAX));

        assert!(!d.is_nan());

        assert!(d >= f64::from(f32::MAX), "distance underreported: {d}");

    }

    #[test]

    fn distance_with_nan_or_inf_coordinates_does_not_panic() {

        // IEEE-754 / C99: hypot(NaN, inf) == inf, hypot(NaN, finite) == NaN.

        assert!(p(0.0, 0.0).distance(p(f32::NAN, 1.0)).is_nan());

        assert!(p(f32::NAN, f32::NAN).distance(p(0.0, 0.0)).is_nan());

        assert!(p(0.0, 0.0).distance(p(f32::INFINITY, 0.0)).is_infinite());

        assert!(p(0.0, 0.0)

            .distance(p(f32::NAN, f32::INFINITY))

            .is_infinite());

    }

    // ---- 5. SvgRect::union_with (other) ------------------------------------

    fn rect(width: f32, height: f32, x: f32, y: f32) -> SvgRect {

        SvgRect {

            width,

            height,

            x,

            y,

            ..SvgRect::default()

        }

    }

    #[test]

    fn union_with_expands_to_cover_both_rects() {

        let mut a = rect(10.0, 10.0, 0.0, 0.0);

        a.union_with(&rect(10.0, 10.0, 20.0, 30.0));

        assert_eq!(a, rect(30.0, 40.0, 0.0, 0.0));

    }

    #[test]

    fn union_with_self_is_idempotent() {

        let mut a = rect(10.0, 20.0, -5.0, -7.0);

        let before = a;

        a.union_with(&before);

        assert_eq!(a, before);

        a.union_with(&before);

        assert_eq!(a, before, "union must be idempotent");

    }

    #[test]

    fn union_with_contained_rect_leaves_the_outer_rect_unchanged() {

        let mut outer = rect(100.0, 100.0, 0.0, 0.0);

        let before = outer;

        outer.union_with(&rect(1.0, 1.0, 50.0, 50.0));

        assert_eq!(outer, before);

    }

    #[test]

    fn union_with_default_rect_always_drags_the_origin_in() {

        // A default SvgRect is a degenerate point at (0,0) - unioning with it is

        // NOT a no-op, it forces the result to contain the origin.

        let mut a = rect(5.0, 5.0, 10.0, 10.0);

        a.union_with(&SvgRect::default());

        assert_eq!(a, rect(15.0, 15.0, 0.0, 0.0));

    }

    #[test]

    fn union_with_nan_rect_is_a_no_op_because_min_max_ignore_nan() {

        // f32::min/max return the non-NaN operand, so a fully poisoned rect

        // cannot corrupt the accumulator. Pin that down.

        let mut a = rect(10.0, 10.0, 0.0, 0.0);

        let before = a;

        a.union_with(&rect(f32::NAN, f32::NAN, f32::NAN, f32::NAN));

        assert_eq!(a, before, "NaN rect must not poison the union");

    }

    #[test]

    fn union_with_infinite_rect_yields_infinite_extent_without_panicking() {

        let mut a = rect(10.0, 10.0, 0.0, 0.0);

        a.union_with(&rect(f32::INFINITY, f32::INFINITY, 0.0, 0.0));

        assert!(a.width.is_infinite() && a.height.is_infinite());

        assert_eq!(a.x, 0.0);

        assert_eq!(a.y, 0.0);

    }

    #[test]

    fn union_with_extreme_opposite_rects_does_not_panic() {

        let mut a = rect(f32::MAX, f32::MAX, f32::MIN, f32::MIN);

        a.union_with(&rect(f32::MAX, f32::MAX, f32::MAX, f32::MAX));

        // max_x - min_x overflows f32 -> inf; the point is that it must not trap.

        assert!(!a.width.is_nan());

        assert!(!a.height.is_nan());

    }

    // ---- 6. SvgRect::contains_point (numeric) ------------------------------

    #[test]

    fn contains_point_is_strictly_exclusive_on_every_edge() {

        let r = rect(10.0, 10.0, 0.0, 0.0);

        assert!(r.contains_point(p(5.0, 5.0)));

        // corners + edges are all *outside* (the impl uses > / <, not >= / <=)

        assert!(!r.contains_point(p(0.0, 0.0)));

        assert!(!r.contains_point(p(10.0, 10.0)));

        assert!(!r.contains_point(p(0.0, 5.0)));

        assert!(!r.contains_point(p(10.0, 5.0)));

        assert!(!r.contains_point(p(5.0, 0.0)));

        assert!(!r.contains_point(p(5.0, 10.0)));

    }

    #[test]

    fn contains_point_zero_sized_rect_contains_nothing() {

        let r = SvgRect::default();

        assert!(!r.contains_point(p(0.0, 0.0)));

        assert!(!r.contains_point(p(1.0, 1.0)));

        assert!(!r.contains_point(p(-1.0, -1.0)));

    }

    #[test]

    fn contains_point_negative_size_rect_contains_nothing() {

        // width < 0 makes `x > self.x && x < self.x + width` unsatisfiable.

        let r = rect(-10.0, -10.0, 0.0, 0.0);

        for pt in [p(0.0, 0.0), p(-5.0, -5.0), p(5.0, 5.0), p(-10.0, -10.0)] {

            assert!(!r.contains_point(pt), "{pt:?} must not be contained");

        }

    }

    #[test]

    fn contains_point_negative_origin_quadrant_works() {

        let r = rect(10.0, 10.0, -20.0, -20.0);

        assert!(r.contains_point(p(-15.0, -15.0)));

        assert!(!r.contains_point(p(-25.0, -15.0)));

        assert!(!r.contains_point(p(0.0, 0.0)));

    }

    #[test]

    fn contains_point_with_nan_coordinates_is_false_not_a_panic() {

        let r = rect(10.0, 10.0, 0.0, 0.0);

        assert!(!r.contains_point(p(f32::NAN, 5.0)));

        assert!(!r.contains_point(p(5.0, f32::NAN)));

        assert!(!r.contains_point(p(f32::NAN, f32::NAN)));

        // ... and a NaN *rect* also swallows everything (all comparisons false).

        let nan_rect = rect(f32::NAN, f32::NAN, f32::NAN, f32::NAN);

        assert!(!nan_rect.contains_point(p(0.0, 0.0)));

    }

    #[test]

    fn contains_point_infinite_rect_contains_finite_points_but_not_infinity() {

        let r = rect(f32::INFINITY, f32::INFINITY, 0.0, 0.0);

        assert!(r.contains_point(p(1e30, 1e30)));

        assert!(!r.contains_point(p(f32::INFINITY, f32::INFINITY)));

        assert!(!r.contains_point(p(-1.0, 1.0)));

    }

    #[test]

    fn contains_point_at_f32_extremes_does_not_panic() {

        let r = rect(f32::MAX, f32::MAX, f32::MIN, f32::MIN);

        // Unlike integers, `f32::MIN == -f32::MAX` exactly, so x + width is exactly

        // 0.0 -- no overflow to +inf. That puts (0,0) exactly ON the rect's corner,

        // and `contains_point` is strictly exclusive on every edge (see

        // `contains_point_is_strictly_exclusive_on_every_edge`), so it is NOT inside.

        let _ = r.contains_point(p(f32::MAX, f32::MAX));

        let _ = r.contains_point(p(f32::MIN, f32::MIN));

        assert!(!r.contains_point(p(0.0, 0.0)));

    }

    // ---- 7. SvgRect::expand (numeric) --------------------------------------

    #[test]

    fn expand_by_zero_is_the_identity() {

        let r = SvgRect {

            width: 10.0,

            height: 20.0,

            x: 1.0,

            y: 2.0,

            radius_top_left: 3.0,

            radius_top_right: 4.0,

            radius_bottom_left: 5.0,

            radius_bottom_right: 6.0,

        };

        assert_eq!(r.expand(0.0, 0.0, 0.0, 0.0), r);

    }

    #[test]

    fn expand_grows_the_rect_and_preserves_the_corner_radii() {

        let r = SvgRect {

            width: 10.0,

            height: 10.0,

            x: 0.0,

            y: 0.0,

            radius_top_left: 3.0,

            radius_top_right: 4.0,

            radius_bottom_left: 5.0,

            radius_bottom_right: 6.0,

        };

        let e = r.expand(1.0, 2.0, 4.0, 8.0);

        assert_eq!(e.width, 10.0 + 4.0 + 8.0);

        assert_eq!(e.height, 10.0 + 1.0 + 2.0);

        assert_eq!(e.x, -4.0);

        assert_eq!(e.y, -1.0);

        // `..*self` must carry the radii over untouched.

        assert_eq!(e.radius_top_left, 3.0);

        assert_eq!(e.radius_top_right, 4.0);

        assert_eq!(e.radius_bottom_left, 5.0);

        assert_eq!(e.radius_bottom_right, 6.0);

    }

    #[test]

    fn expand_with_negative_padding_shrinks_and_may_invert_the_rect() {

        let r = rect(10.0, 10.0, 0.0, 0.0);

        assert_eq!(r.expand(-1.0, -1.0, -1.0, -1.0), rect(8.0, 8.0, 1.0, 1.0));

        // Over-shrinking is *not* clamped: the width goes negative.

        let inverted = r.expand(-100.0, -100.0, -100.0, -100.0);

        assert!(inverted.width < 0.0, "expand does not clamp to zero");

        assert!(!inverted.contains_point(p(5.0, 5.0)));

    }

    #[test]

    fn expand_overflow_saturates_to_infinity_instead_of_panicking() {

        let r = rect(f32::MAX, f32::MAX, 0.0, 0.0);

        let e = r.expand(f32::MAX, f32::MAX, f32::MAX, f32::MAX);

        // width = MAX + MAX + MAX overflows -> +inf ...

        assert!(e.width.is_infinite() && e.width > 0.0);

        assert!(e.height.is_infinite() && e.height > 0.0);

        // ... but the origin is a single subtraction, which stays in range.

        assert_eq!(e.x, -f32::MAX);

        assert_eq!(e.y, -f32::MAX);

        assert!(e.x.is_finite() && e.y.is_finite());

    }

    #[test]

    fn expand_with_nan_padding_poisons_the_rect_but_does_not_panic() {

        let r = rect(10.0, 10.0, 0.0, 0.0);

        let e = r.expand(f32::NAN, 0.0, 0.0, 0.0);

        assert!(e.height.is_nan());

        assert!(e.y.is_nan());

        // NaN dimensions make the rect vacuous rather than crashing consumers.

        assert!(!e.contains_point(p(5.0, 5.0)));

    }

    #[test]

    fn expand_with_infinite_padding_produces_infinite_extent() {

        let r = rect(1.0, 1.0, 0.0, 0.0);

        let e = r.expand(f32::INFINITY, f32::INFINITY, f32::INFINITY, f32::INFINITY);

        assert!(e.width.is_infinite());

        assert!(e.x.is_infinite() && e.x < 0.0);

    }

    // ---- 8. SvgRect::get_center (getter) -----------------------------------

    #[test]

    fn get_center_of_a_known_rect() {

        assert_eq!(rect(10.0, 20.0, 2.0, 4.0).get_center(), p(7.0, 14.0));

        assert_eq!(rect(1.0, 1.0, 0.0, 0.0).get_center(), p(0.5, 0.5));

    }

    #[test]

    fn get_center_of_default_rect_is_the_origin() {

        assert_eq!(SvgRect::default().get_center(), SvgPoint::default());

    }

    #[test]

    fn get_center_of_a_contained_rect_is_inside_it() {

        let r = rect(10.0, 10.0, -3.0, 7.5);

        assert!(r.contains_point(r.get_center()));

    }

    #[test]

    fn get_center_at_extremes_does_not_panic() {

        let inf = rect(f32::INFINITY, f32::INFINITY, 0.0, 0.0).get_center();

        assert!(inf.x.is_infinite() && inf.y.is_infinite());

        // width/2 keeps f32::MAX in range, so no overflow here.

        let huge = rect(f32::MAX, f32::MAX, 0.0, 0.0).get_center();

        assert!(huge.x.is_finite() && huge.y.is_finite());

        let nan = rect(f32::NAN, f32::NAN, 0.0, 0.0).get_center();

        assert!(nan.x.is_nan() && nan.y.is_nan());

    }

    // ---- 9-12. SvgCubicCurve new / reverse / get_start / get_end -----------

    #[test]

    fn cubic_new_stores_all_four_control_points_verbatim() {

        let c = SvgCubicCurve::new(p(1.0, 2.0), p(3.0, 4.0), p(5.0, 6.0), p(7.0, 8.0));

        assert_eq!(c.start, p(1.0, 2.0));

        assert_eq!(c.ctrl_1, p(3.0, 4.0));

        assert_eq!(c.ctrl_2, p(5.0, 6.0));

        assert_eq!(c.end, p(7.0, 8.0));

        assert_eq!(c.get_start(), c.start);

        assert_eq!(c.get_end(), c.end);

    }

    #[test]

    fn cubic_new_accepts_extreme_control_points() {

        let c = SvgCubicCurve::new(

            p(f32::MIN, f32::MAX),

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

            p(f32::MIN_POSITIVE, -0.0),

            p(0.0, 0.0),

        );

        assert!(c.get_start().x.is_finite());

        assert!(c.ctrl_1.x.is_infinite());

        assert_eq!(c.get_end(), p(0.0, 0.0));

    }

    #[test]

    fn cubic_reverse_swaps_the_endpoints_and_the_control_points() {

        let mut c = SvgCubicCurve::new(p(1.0, 2.0), p(3.0, 4.0), p(5.0, 6.0), p(7.0, 8.0));

        c.reverse();

        assert_eq!(c.start, p(7.0, 8.0));

        assert_eq!(c.ctrl_1, p(5.0, 6.0));

        assert_eq!(c.ctrl_2, p(3.0, 4.0));

        assert_eq!(c.end, p(1.0, 2.0));

    }

    #[test]

    fn cubic_reverse_twice_is_the_identity() {

        let original = exact_curve();

        let mut c = original;

        c.reverse();

        assert_ne!(c, original);

        c.reverse();

        assert_eq!(c, original, "reverse must be an involution");

    }

    #[test]

    fn cubic_reverse_mirrors_the_parameterization() {

        // round-trip: reversed(t) == original(1 - t)

        let original = exact_curve();

        let mut reversed = original;

        reversed.reverse();

        for step in 0..=10 {

            let t = f64::from(step) / 10.0;

            assert!(approx(

                reversed.get_x_at_t(t),

                original.get_x_at_t(1.0 - t),

                1e-12

            ));

            assert!(approx(

                reversed.get_y_at_t(t),

                original.get_y_at_t(1.0 - t),

                1e-12

            ));

        }

    }

    #[test]

    fn cubic_reverse_on_a_degenerate_curve_does_not_panic() {

        let mut c = degenerate_curve();

        c.reverse();

        assert_eq!(c, degenerate_curve());

    }

    // ---- 13-14. SvgCubicCurve::get_x_at_t / get_y_at_t (numeric) -----------

    #[test]

    fn cubic_endpoints_are_hit_exactly_at_t_0_and_t_1() {

        let c = exact_curve();

        assert_eq!(c.get_x_at_t(0.0), f64::from(c.start.x));

        assert_eq!(c.get_y_at_t(0.0), f64::from(c.start.y));

        assert!(approx(c.get_x_at_t(1.0), f64::from(c.end.x), 1e-12));

        assert!(approx(c.get_y_at_t(1.0), f64::from(c.end.y), 1e-12));

    }

    #[test]

    fn cubic_negative_zero_t_behaves_like_zero() {

        let c = exact_curve();

        assert_eq!(c.get_x_at_t(-0.0), c.get_x_at_t(0.0));

        assert_eq!(c.get_y_at_t(-0.0), c.get_y_at_t(0.0));

    }

    #[test]

    fn cubic_stays_within_the_control_hull_for_t_in_unit_range() {

        // A bezier curve never leaves the convex hull of its control points.

        let c = exact_curve();

        let bounds = c.get_bounds();

        for step in 0..=20 {

            let t = f64::from(step) / 20.0;

            let x = c.get_x_at_t(t);

            let y = c.get_y_at_t(t);

            assert!(

                x >= f64::from(bounds.x) - 1e-9 && x <= f64::from(bounds.x + bounds.width) + 1e-9,

                "x left the hull at t = {t}: {x}"

            );

            assert!(

                y >= f64::from(bounds.y) - 1e-9 && y <= f64::from(bounds.y + bounds.height) + 1e-9,

                "y left the hull at t = {t}: {y}"

            );

        }

    }

    #[test]

    fn cubic_evaluation_extrapolates_outside_the_unit_range_without_clamping() {

        // t is NOT clamped: t < 0 / t > 1 extrapolate the polynomial.

        let c = AnimationInterpolationFunction::Linear.get_curve();

        // y(t) = -2t^3 + 3t^2  =>  y(-1) = 5, y(2) = -4

        assert_eq!(c.get_y_at_t(-1.0), 5.0);

        assert_eq!(c.get_y_at_t(2.0), -4.0);

    }

    #[test]

    fn cubic_evaluation_at_nan_and_inf_is_defined_and_never_panics() {

        let c = exact_curve();

        assert!(c.get_x_at_t(f64::NAN).is_nan());

        assert!(c.get_y_at_t(f64::NAN).is_nan());

        for t in NASTY_F64 {

            let x = c.get_x_at_t(t);

            let y = c.get_y_at_t(t);

            // finite t inside [0,1] must produce finite output; everything else

            // may blow up, but only ever into inf/NaN - never into a panic.

            if (0.0..=1.0).contains(&t) {

                assert!(x.is_finite() && y.is_finite(), "finite t={t} gave {x}/{y}");

            }

        }

    }

    #[test]

    fn cubic_evaluation_at_huge_t_overflows_instead_of_returning_a_bogus_finite() {

        let c = AnimationInterpolationFunction::Linear.get_curve();

        for t in [f64::MAX, f64::MIN, 1e300, -1e300, f64::INFINITY] {

            assert!(

                !c.get_x_at_t(t).is_finite(),

                "t = {t} must not produce a finite x"

            );

            assert!(!c.get_y_at_t(t).is_finite());

        }

    }

    #[test]

    fn cubic_with_infinite_control_points_yields_nan_not_a_panic() {

        let c = SvgCubicCurve::new(p(f32::INFINITY, 0.0), p(0.0, 0.0), p(0.0, 0.0), p(1.0, 1.0));

        // inf appears in every coefficient -> inf - inf == NaN somewhere.

        assert!(!c.get_x_at_t(0.5).is_finite());

    }

    // ---- 15. SvgCubicCurve::get_length (getter) ----------------------------

    #[test]

    fn cubic_length_of_the_linear_timing_curve_is_the_unit_diagonal() {

        // The Linear curve traces y = x from (0,0) to (1,1) => length = sqrt(2).

        let len = AnimationInterpolationFunction::Linear

            .get_curve()

            .get_length();

        assert!(

            approx(len, core::f64::consts::SQRT_2, 1e-4),

            "expected ~sqrt(2), got {len}"