//! CSS property types for direction (for gradients).

use alloc::string::String;

use core::{fmt, num::ParseFloatError};

use crate::{

    corety::AzString,

    props::{

        basic::{

            angle::{

                parse_angle_value, AngleValue, CssAngleValueParseError,

                CssAngleValueParseErrorOwned,

            },

            geometry::{LayoutPoint, LayoutRect},

        },

        formatter::PrintAsCssValue,

    },

};

/// Corner or side of a rectangle, used to specify CSS gradient directions

/// (e.g. `to top right`).

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

#[repr(C)]

pub enum DirectionCorner {

    Right,

    Left,

    Top,

    Bottom,

    TopRight,

    TopLeft,

    BottomRight,

    BottomLeft,

}

impl fmt::Display for DirectionCorner {

            }

        )

}

impl PrintAsCssValue for DirectionCorner {

}

impl DirectionCorner {

    #[must_use]

        use self::DirectionCorner::{

            Bottom, BottomLeft, BottomRight, Left, Right, Top, TopLeft, TopRight,

        };

        }

    #[must_use]

        use self::DirectionCorner::{

            Bottom, BottomLeft, BottomRight, Left, Right, Top, TopLeft, TopRight,

        };

        }

    #[must_use]

        use self::DirectionCorner::{

            Bottom, BottomLeft, BottomRight, Left, Right, Top, TopLeft, TopRight,

        };

        }

}

/// A pair of corners representing the start and end of a CSS gradient direction.

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

#[repr(C)]

pub struct DirectionCorners {

    /// The corner or side from which the gradient starts.

    pub dir_from: DirectionCorner,

    /// The corner or side at which the gradient ends.

    pub dir_to: DirectionCorner,

}

/// CSS direction (necessary for gradients). Can either be a fixed angle or

/// a direction ("to right" / "to left", etc.).

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

#[repr(C, u8)]

pub enum Direction {

    Angle(AngleValue),

    FromTo(DirectionCorners),

}

impl Default for Direction {

}

impl PrintAsCssValue for Direction {

        }

}

impl Direction {

    #[must_use]

                // Convert the angle to start/end points on the rectangle.

                // Normalize to [0, 360) so negative angles and angles >= 360 fall

                // into the same quadrant branches below (rem_euclid is always >= 0).

                } else {

                };

            }

        }

}

// -- Parser

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

pub enum CssDirectionCornerParseError<'a> {

    InvalidDirection(&'a str),

}

impl_display! { CssDirectionCornerParseError<'a>, {

    InvalidDirection(val) => format!("Invalid direction: \"{}\"", val),

}}

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

#[repr(C, u8)]

pub enum CssDirectionCornerParseErrorOwned {

    InvalidDirection(AzString),

}

impl CssDirectionCornerParseError<'_> {

    #[must_use]

            }

        }

}

impl CssDirectionCornerParseErrorOwned {

    #[must_use]

        }

}

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

pub enum CssDirectionParseError<'a> {

    Error(&'a str),

    InvalidArguments(&'a str),

    ParseFloat(ParseFloatError),

    CornerError(CssDirectionCornerParseError<'a>),

    AngleError(CssAngleValueParseError<'a>),

}

impl_display! {CssDirectionParseError<'a>, {

    Error(e) => e,

    InvalidArguments(val) => format!("Invalid arguments: \"{}\"", val),

    ParseFloat(e) => format!("Invalid value: {}", e),

    CornerError(e) => format!("Invalid corner value: {}", e),

    AngleError(e) => format!("Invalid angle value: {}", e),

}}

impl From<ParseFloatError> for CssDirectionParseError<'_> {

}

impl_from! { CssDirectionCornerParseError<'a>, CssDirectionParseError::CornerError }

impl_from! { CssAngleValueParseError<'a>, CssDirectionParseError::AngleError }

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

#[repr(C, u8)]

pub enum CssDirectionParseErrorOwned {

    Error(AzString),

    InvalidArguments(AzString),

    ParseFloat(crate::props::basic::error::ParseFloatError),

    CornerError(CssDirectionCornerParseErrorOwned),

    AngleError(CssAngleValueParseErrorOwned),

}

impl CssDirectionParseError<'_> {

    #[must_use]

            }

            }

            }

            }

            }

        }

}

impl CssDirectionParseErrorOwned {

    #[must_use]

        }

}

#[cfg(feature = "parser")]

    }

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `direction` value.

    } else {

    };

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

mod tests {

    use super::*;

    use crate::props::basic::angle::AngleValue;

    #[test]

        );

        );

    #[test]

            Direction::FromTo(DirectionCorners {

                dir_from: DirectionCorner::Left,

                dir_to: DirectionCorner::Right,

            })

        );

            Direction::FromTo(DirectionCorners {

                dir_from: DirectionCorner::BottomRight,

                dir_to: DirectionCorner::TopLeft,

            })

        );

            Direction::FromTo(DirectionCorners {

                dir_from: DirectionCorner::BottomRight,

                dir_to: DirectionCorner::TopLeft,

            })

        );

    #[test]

}

#[cfg(test)]

mod autotest_generated {

    // Angles/coordinates are compared against exact literals that the code under

    // test can reproduce bit-for-bit (or with an explicit ±1 pixel tolerance).

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

    use alloc::collections::BTreeSet;

    use super::*;

    use crate::props::basic::geometry::LayoutSize;

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

    const ALL_CORNERS: [DirectionCorner; 8] = [

        DirectionCorner::Right,

        DirectionCorner::Left,

        DirectionCorner::Top,

        DirectionCorner::Bottom,

        DirectionCorner::TopRight,

        DirectionCorner::TopLeft,

        DirectionCorner::BottomRight,

        DirectionCorner::BottomLeft,

    ];

    const SIDES: [DirectionCorner; 4] = [

        DirectionCorner::Right,

        DirectionCorner::Left,

        DirectionCorner::Top,

        DirectionCorner::Bottom,

    ];

    const DIAGONALS: [DirectionCorner; 4] = [

        DirectionCorner::TopRight,

        DirectionCorner::TopLeft,

        DirectionCorner::BottomRight,

        DirectionCorner::BottomLeft,

    ];

    fn rect(w: isize, h: isize) -> LayoutRect {

        LayoutRect::new(LayoutPoint::zero(), LayoutSize::new(w, h))

    }

    fn rect_at(x: isize, y: isize, w: isize, h: isize) -> LayoutRect {

        LayoutRect::new(LayoutPoint::new(x, y), LayoutSize::new(w, h))

    }

    /// Canonical direction: `to <corner>`, i.e. starting at the opposite corner.

    fn canonical(dir_to: DirectionCorner) -> Direction {

        Direction::FromTo(DirectionCorners {

            dir_from: dir_to.opposite(),

            dir_to,

        })

    }

    fn assert_near(actual: LayoutPoint, expected: LayoutPoint, tol: isize) {

        assert!(

            (actual.x - expected.x).abs() <= tol && (actual.y - expected.y).abs() <= tol,

            "expected {expected:?} (±{tol}), got {actual:?}"

        );

    }

    // ---- const-evaluability of the `const fn`s -----------------------------

    const CONST_RECT: LayoutRect =

        LayoutRect::new(LayoutPoint::new(7, 9), LayoutSize::new(200, 100));

    const CONST_OPPOSITE: DirectionCorner = DirectionCorner::TopRight.opposite();

    const CONST_COMBINED: Option<DirectionCorner> =

        DirectionCorner::Right.combine(&DirectionCorner::Top);

    const CONST_POINT: LayoutPoint = DirectionCorner::Right.to_point(&CONST_RECT);

    #[test]

    fn const_fns_evaluate_at_compile_time() {

        assert_eq!(CONST_OPPOSITE, DirectionCorner::BottomLeft);

        assert_eq!(CONST_COMBINED, Some(DirectionCorner::TopRight));

        // to_point() is rect-local: the origin (7, 9) is not added.

        assert_eq!(CONST_POINT, LayoutPoint::new(200, 50));

    }

    // ---- DirectionCorner: Display / PrintAsCssValue (serializer) ------------

    #[test]

    fn corner_display_exact_values_and_wellformed() {

        let expected = [

            (DirectionCorner::Right, "right"),

            (DirectionCorner::Left, "left"),

            (DirectionCorner::Top, "top"),

            (DirectionCorner::Bottom, "bottom"),

            (DirectionCorner::TopRight, "top right"),

            (DirectionCorner::TopLeft, "top left"),

            (DirectionCorner::BottomRight, "bottom right"),

            (DirectionCorner::BottomLeft, "bottom left"),

        ];

        for (corner, want) in expected {

            let printed = format!("{corner}");

            assert_eq!(printed, want);

            // PrintAsCssValue must agree with Display.

            assert_eq!(corner.print_as_css_value(), printed);

            // Well-formed: non-empty, ASCII, lowercase, no stray whitespace.

            assert!(!printed.is_empty());

            assert!(printed.is_ascii());

            assert_eq!(printed, printed.to_lowercase());

            assert_eq!(printed, printed.trim());

        }

    }

    #[test]

    fn corner_display_is_injective() {

        let printed: BTreeSet<String> = ALL_CORNERS.iter().map(|c| format!("{c}")).collect();

        assert_eq!(printed.len(), ALL_CORNERS.len());

    }

    #[test]

    fn direction_default_and_display_do_not_panic() {

        // no_panic_default: Default::default() serializes.

        assert_eq!(

            Direction::default(),

            Direction::FromTo(DirectionCorners {

                dir_from: DirectionCorner::Top,

                dir_to: DirectionCorner::Bottom,

            })

        );

        assert_eq!(Direction::default().print_as_css_value(), "to bottom");

        // edge_values: NaN / infinite angles must still serialize without panic.

        for v in [

            0.0_f32,

            -0.0,

            f32::NAN,

            f32::INFINITY,

            f32::NEG_INFINITY,

            f32::MAX,

            f32::MIN,

            f32::MIN_POSITIVE,

        ] {

            let s = Direction::Angle(AngleValue::deg(v)).print_as_css_value();

            assert!(!s.is_empty(), "empty serialization for {v}");

            assert!(s.ends_with("deg"), "unexpected serialization: {s}");

            // The fixed-point encoding must never leak NaN/inf into the output.

            assert!(!s.contains("NaN"), "NaN leaked into CSS output: {s}");

            assert!(!s.contains("inf"), "inf leaked into CSS output: {s}");

        }

    }

    // ---- DirectionCorner::opposite (getter) --------------------------------

    #[test]

    fn opposite_known_values() {

        assert_eq!(DirectionCorner::Right.opposite(), DirectionCorner::Left);

        assert_eq!(DirectionCorner::Left.opposite(), DirectionCorner::Right);

        assert_eq!(DirectionCorner::Top.opposite(), DirectionCorner::Bottom);

        assert_eq!(DirectionCorner::Bottom.opposite(), DirectionCorner::Top);

        assert_eq!(

            DirectionCorner::TopRight.opposite(),

            DirectionCorner::BottomLeft

        );

        assert_eq!(

            DirectionCorner::BottomLeft.opposite(),

            DirectionCorner::TopRight

        );

        assert_eq!(

            DirectionCorner::TopLeft.opposite(),

            DirectionCorner::BottomRight

        );

        assert_eq!(

            DirectionCorner::BottomRight.opposite(),

            DirectionCorner::TopLeft

        );

    }

    #[test]

    fn opposite_is_an_involution_and_a_bijection() {

        let mut images = BTreeSet::new();

        for c in ALL_CORNERS {

            // No fixed points: a corner is never its own opposite.

            assert_ne!(c.opposite(), c, "{c} is its own opposite");

            // Involution.

            assert_eq!(c.opposite().opposite(), c, "opposite² != id for {c}");

            // A side maps to a side, a diagonal maps to a diagonal.

            assert_eq!(

                SIDES.contains(&c),

                SIDES.contains(&c.opposite()),

                "{c} changed class under opposite()"

            );

            images.insert(c.opposite());

        }

        assert_eq!(images.len(), 8, "opposite() is not a bijection");

    }

    // ---- DirectionCorner::combine (other) ----------------------------------

    #[test]

    fn combine_exhaustive_over_all_64_pairs() {

        let mut some_count = 0_usize;

        for a in ALL_CORNERS {

            for b in ALL_CORNERS {

                let r = a.combine(&b);

                // Commutative.

                assert_eq!(r, b.combine(&a), "combine({a}, {b}) is not commutative");

                match r {

                    Some(c) => {

                        some_count += 1;

                        // Only perpendicular side pairs may combine, and the

                        // result is always a diagonal.

                        assert!(SIDES.contains(&a) && SIDES.contains(&b));

                        assert!(

                            DIAGONALS.contains(&c),

                            "combine({a}, {b}) = {c}, not a corner"

                        );

                        assert_ne!(a, b);

                        assert_ne!(a.opposite(), b, "opposite sides must not combine");

                        // The corner name must mention both inputs.

                        let name = format!("{c}");

                        assert!(name.contains(&format!("{a}")) && name.contains(&format!("{b}")));

                        // Combining the opposites yields the opposite corner.

                        assert_eq!(a.opposite().combine(&b.opposite()), Some(c.opposite()));

                    }

                    None => {

                        assert!(

                            !SIDES.contains(&a)

                                || !SIDES.contains(&b)

                                || a == b

                                || a.opposite() == b,

                            "combine({a}, {b}) unexpectedly returned None"

                        );

                    }

                }

            }

        }

        // Exactly the 4 corners × 2 orderings.

        assert_eq!(some_count, 8);

    }

    #[test]

    fn combine_degenerate_pairs_are_none() {

        for c in ALL_CORNERS {

            assert_eq!(c.combine(&c), None, "{c} combined with itself");

            assert_eq!(c.combine(&c.opposite()), None, "{c} combined with opposite");

        }

        assert_eq!(DirectionCorner::Top.combine(&DirectionCorner::Bottom), None);

        assert_eq!(DirectionCorner::Left.combine(&DirectionCorner::Right), None);

        // A diagonal never combines with anything.

        for d in DIAGONALS {

            for c in ALL_CORNERS {

                assert_eq!(d.combine(&c), None, "{d} combined with {c}");

            }

        }

    }

    // ---- DirectionCorner::to_point (numeric) -------------------------------

    #[test]

    fn to_point_zero_rect_is_origin() {

        let r = rect(0, 0);

        for c in ALL_CORNERS {

            assert_eq!(c.to_point(&r), LayoutPoint::zero(), "corner {c}");

        }

    }

    #[test]

    fn to_point_known_values() {

        let r = rect(200, 100);

        assert_eq!(

            DirectionCorner::Right.to_point(&r),

            LayoutPoint::new(200, 50)

        );

        assert_eq!(DirectionCorner::Left.to_point(&r), LayoutPoint::new(0, 50));

        assert_eq!(DirectionCorner::Top.to_point(&r), LayoutPoint::new(100, 0));

        assert_eq!(

            DirectionCorner::Bottom.to_point(&r),

            LayoutPoint::new(100, 100)

        );

        assert_eq!(

            DirectionCorner::TopRight.to_point(&r),

            LayoutPoint::new(200, 0)

        );

        assert_eq!(

            DirectionCorner::TopLeft.to_point(&r),

            LayoutPoint::new(0, 0)

        );

        assert_eq!(

            DirectionCorner::BottomRight.to_point(&r),

            LayoutPoint::new(200, 100)

        );

        assert_eq!(

            DirectionCorner::BottomLeft.to_point(&r),

            LayoutPoint::new(0, 100)

        );

    }

    #[test]

    fn to_point_ignores_rect_origin() {

        // to_point() works in rect-local space: a far-away (even negative)

        // origin must not shift the result.

        let local = rect(200, 100);

        for offset in [(0, 0), (1000, -500), (isize::MIN, isize::MAX)] {

            let moved = rect_at(offset.0, offset.1, 200, 100);

            for c in ALL_CORNERS {

                assert_eq!(

                    c.to_point(&moved),

                    c.to_point(&local),

                    "corner {c} shifted by origin {offset:?}"

                );

            }

        }

    }

    #[test]

    fn to_point_opposite_corners_sum_to_the_full_extent() {

        // p(c) + p(opposite(c)) == (width, height) for even extents.

        for (w, h) in [(200_isize, 100_isize), (2, 2), (0, 0), (-40, -60)] {

            let r = rect(w, h);

            for c in ALL_CORNERS {

                let p = c.to_point(&r);

                let q = c.opposite().to_point(&r);

                assert_eq!(p.x + q.x, w, "x-sum for {c} in {w}x{h}");

                assert_eq!(p.y + q.y, h, "y-sum for {c} in {w}x{h}");

            }

        }

    }

    #[test]

    fn to_point_odd_and_negative_extents_truncate_toward_zero() {

        // Rust integer division truncates toward zero: 3/2 == 1, -3/2 == -1.

        let r = rect(3, 3);

        assert_eq!(DirectionCorner::Top.to_point(&r), LayoutPoint::new(1, 0));

        assert_eq!(DirectionCorner::Right.to_point(&r), LayoutPoint::new(3, 1));

        let neg = rect(-3, -3);

        assert_eq!(DirectionCorner::Top.to_point(&neg), LayoutPoint::new(-1, 0));

        assert_eq!(

            DirectionCorner::Right.to_point(&neg),

            LayoutPoint::new(-3, -1)

        );

        assert_eq!(

            DirectionCorner::BottomLeft.to_point(&neg),

            LayoutPoint::new(0, -3)

        );

    }

    #[test]

    fn to_point_isize_extremes_do_not_overflow() {

        // Halving isize::MIN / isize::MAX is the only arithmetic here; neither

        // can overflow (the divisor is a constant 2), so no debug-panic.

        let max = rect(isize::MAX, isize::MAX);

        assert_eq!(

            DirectionCorner::Right.to_point(&max),

            LayoutPoint::new(isize::MAX, isize::MAX / 2)

        );

        assert_eq!(

            DirectionCorner::Bottom.to_point(&max),

            LayoutPoint::new(isize::MAX / 2, isize::MAX)

        );

        assert_eq!(

            DirectionCorner::BottomRight.to_point(&max),

            LayoutPoint::new(isize::MAX, isize::MAX)

        );

        let min = rect(isize::MIN, isize::MIN);

        assert_eq!(

            DirectionCorner::Right.to_point(&min),

            LayoutPoint::new(isize::MIN, isize::MIN / 2)

        );

        assert_eq!(

            DirectionCorner::Top.to_point(&min),

            LayoutPoint::new(isize::MIN / 2, 0)

        );

        // Mixed extremes: every corner stays inside the rect's own bounds.

        let mixed = rect(isize::MAX, isize::MIN);

        for c in ALL_CORNERS {

            let p = c.to_point(&mixed);

            assert!(p.x == 0 || p.x == isize::MAX || p.x == isize::MAX / 2);

            assert!(p.y == 0 || p.y == isize::MIN || p.y == isize::MIN / 2);

        }

    }

    // ---- Direction::to_points (numeric) ------------------------------------

    #[test]

    fn to_points_fromto_delegates_to_to_point() {

        let r = rect(200, 100);

        for from in ALL_CORNERS {

            for to in ALL_CORNERS {

                let d = Direction::FromTo(DirectionCorners {

                    dir_from: from,

                    dir_to: to,

                });

                assert_eq!(d.to_points(&r), (from.to_point(&r), to.to_point(&r)));

            }

        }

    }

    #[test]

    fn to_points_angle_zero_deg_runs_bottom_to_top() {

        // CSS: 0deg == "to top", so the gradient starts at the bottom edge.

        let r = rect(100, 100);

        let (start, end) = Direction::Angle(AngleValue::deg(0.0)).to_points(&r);

        assert_near(start, LayoutPoint::new(50, 100), 1);

        assert_near(end, LayoutPoint::new(50, 0), 1);

    }

    #[test]

    fn to_points_angle_180_deg_runs_top_to_bottom() {

        // CSS: 180deg == "to bottom".

        let r = rect(100, 100);

        let (start, end) = Direction::Angle(AngleValue::deg(180.0)).to_points(&r);

        assert_near(start, LayoutPoint::new(50, 0), 1);

        assert_near(end, LayoutPoint::new(50, 100), 1);

    }

    #[test]

    fn to_points_angle_90_deg_is_horizontal_across_the_full_width() {

        let r = rect(100, 100);

        let (start, end) = Direction::Angle(AngleValue::deg(90.0)).to_points(&r);

        // Both endpoints sit on the horizontal midline, at the two extremes.

        assert!((start.y - 50).abs() <= 1, "start.y = {}", start.y);

        assert!((end.y - 50).abs() <= 1, "end.y = {}", end.y);

        let mut xs = [start.x, end.x];

        xs.sort_unstable();

        assert!(xs[0].abs() <= 1 && (xs[1] - 100).abs() <= 1, "xs = {xs:?}");

        assert_ne!(start, end);

    }

    #[test]

    fn to_points_angle_is_symmetric_about_the_rect_center() {

        // start = center - d, end = center + d (mod rounding), for *every* angle

        // and metric — so the endpoints must always straddle the center.

        let r = rect(200, 100);

        let mut angles = Vec::new();

        let mut deg = -720.0_f32;

        while deg <= 720.0 {

            angles.push(AngleValue::deg(deg));

            deg += 15.0;

        }

        angles.extend([

            AngleValue::rad(1.5),

            AngleValue::rad(-3.0),

            AngleValue::grad(100.0),

            AngleValue::grad(-400.0),

            AngleValue::turn(0.25),

            AngleValue::turn(-2.5),

            AngleValue::percent(50.0),

            AngleValue::percent(-125.0),

        ]);

        for a in angles {

            let (start, end) = Direction::Angle(a).to_points(&r);

            assert!(

                (start.x + end.x - 200).abs() <= 1,

                "x not centered for {a}: {start:?} / {end:?}"

            );

            assert!(

                (start.y + end.y - 100).abs() <= 1,

                "y not centered for {a}: {start:?} / {end:?}"

            );

            // The half-length is the corner projected onto the gradient line, so

            // it can never exceed the center-to-corner distance (~111.8 here).

            // (The endpoints themselves may fall outside a non-square box.)

            // |start - end| == 2 * L <= 2 * hypot(100, 50) == 223.6 (+ rounding).

            let len_sq = (start.x - end.x).pow(2) + (start.y - end.y).pow(2);

            assert!(

                len_sq <= 4 * (100 * 100 + 50 * 50) + 1000,

                "gradient line longer than the rect diagonal for {a}: {start:?} / {end:?}"

            );

        }

    }

    #[test]

    fn to_points_zero_sized_rect_yields_origin_not_nan() {

        // width_half == height_half == 0 => atan(0/0) == NaN propagates through

        // the whole computation; the f32 -> isize cast saturates NaN to 0, so

        // the result must be (0,0)/(0,0) rather than a panic or garbage.

        let r = rect(0, 0);

        for a in [

            AngleValue::deg(0.0),

            AngleValue::deg(45.0),

            AngleValue::deg(-137.5),

            AngleValue::turn(0.75),

        ] {

            let (start, end) = Direction::Angle(a).to_points(&r);

            assert_eq!(start, LayoutPoint::zero(), "start for {a}");

            assert_eq!(end, LayoutPoint::zero(), "end for {a}");

        }

    }

    #[test]

    fn to_points_degenerate_axis_rects_do_not_panic() {

        // Zero width => height/width == +-inf => atan(inf) == 90deg. Must not panic.

        let thin = rect(0, 100);

        let (s, e) = Direction::Angle(AngleValue::deg(0.0)).to_points(&thin);

        assert_eq!(s.x, 0);

        assert_eq!(e.x, 0);

        assert!((s.y + e.y - 100).abs() <= 1);

        let flat = rect(100, 0);

        let (s, e) = Direction::Angle(AngleValue::deg(90.0)).to_points(&flat);

        assert_eq!(s.y, 0);

        assert_eq!(e.y, 0);

        assert!((s.x + e.x - 100).abs() <= 1);

    }

    #[test]

    fn to_points_nan_angle_collapses_to_zero_degrees() {

        // FloatValue::new(NaN) -> f32_to_isize(NaN) == 0, so a NaN angle is

        // silently the same value as 0deg. Assert the collapse (no NaN escapes).

        let nan = AngleValue::deg(f32::NAN);

        assert!(nan.to_degrees().is_finite());

        assert_eq!(nan.to_degrees(), 0.0);

        assert_eq!(nan, AngleValue::deg(0.0));

        let r = rect(100, 100);

        assert_eq!(

            Direction::Angle(nan).to_points(&r),

            Direction::Angle(AngleValue::deg(0.0)).to_points(&r)

        );

    }

    #[test]

    fn to_points_infinite_angle_saturates_and_stays_finite() {

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

            let a = AngleValue::deg(v);

            let deg = a.to_degrees();

            assert!(deg.is_finite(), "non-finite degrees for {v}");

            assert!((0.0..=360.0).contains(&deg), "{v} normalized to {deg}");

            let r = rect(200, 100);

            let first = Direction::Angle(a).to_points(&r);

            // Deterministic (no NaN-dependent branch flapping).

            assert_eq!(first, Direction::Angle(a).to_points(&r));

        }

    }

    #[test]

    fn to_points_isize_extreme_rects_do_not_panic() {

        for (w, h) in [

            (isize::MAX, isize::MAX),

            (isize::MIN, isize::MIN),

            (isize::MAX, isize::MIN),

            (isize::MIN, 1),

            (-1, isize::MAX),

        ] {

            let r = rect(w, h);

            for a in [

                AngleValue::deg(45.0),

                AngleValue::deg(0.0),

                AngleValue::deg(270.0),

            ] {

                let d = Direction::Angle(a);

                // The f32 round-trip saturates instead of panicking; only assert

                // that the computation terminates and is deterministic.

                assert_eq!(d.to_points(&r), d.to_points(&r), "{w}x{h} @ {a}");

            }

            // The FromTo path on extreme rects is exact.

            let d = canonical(DirectionCorner::BottomRight);

            assert_eq!(d.to_points(&r).1, LayoutPoint::new(w, h));

        }

    }

    // ---- parse_direction_corner (parser, private) ---------------------------

    #[cfg(feature = "parser")]

    #[test]

    fn parse_corner_valid_minimal() {

        assert_eq!(parse_direction_corner("right"), Ok(DirectionCorner::Right));

        assert_eq!(parse_direction_corner("left"), Ok(DirectionCorner::Left));

        assert_eq!(parse_direction_corner("top"), Ok(DirectionCorner::Top));

        assert_eq!(

            parse_direction_corner("bottom"),

            Ok(DirectionCorner::Bottom)

        );

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_corner_rejects_untrimmed_cased_and_diagonal_input() {

        // parse_direction_corner does NOT trim and is case-sensitive; every one

        // of these must be a clean Err carrying the input verbatim.

        for bad in [

            "",

            " ",

            "   ",

            "\t",

            "\n",

            "\r\n",

            " right",

            "right ",

            "right\n",

            "Right",

            "RIGHT",

            "rIgHt",

            "top right",

            "top-right",

            "topright",

            "right;",

            "right)",

            "center",

            "start",

            "end",

            "to",

            "to right",

        ] {

            assert_eq!(

                parse_direction_corner(bad),

                Err(CssDirectionCornerParseError::InvalidDirection(bad)),

                "input {bad:?} was not rejected verbatim"

            );

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_corner_garbage_and_unicode_do_not_panic() {

        for bad in [

            "!@#$%^&*()",

            "\u{0}",

            "\u{0}right",

            "right\u{0}",

            "\u{1F600}",

            "to \u{1F600}",

            "ri\u{0301}ght", // combining acute on 'i'

            "\u{0440}ight",  // Cyrillic 'р'

            "\u{200b}right", // zero-width space (not Rust whitespace)

            "right\u{200b}",

            "\u{feff}right", // BOM

            "\u{202e}right", // RTL override

            "ｒｉｇｈｔ",    // fullwidth

            "\u{a0}right",   // NBSP (Rust whitespace, but not trimmed here)

        ] {

            assert_eq!(

                parse_direction_corner(bad),

                Err(CssDirectionCornerParseError::InvalidDirection(bad)),

                "unicode input {bad:?} was not rejected"

            );

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_corner_boundary_numbers_are_rejected() {

        for bad in [

            "0",

            "-0",

            "9223372036854775807",

            "-9223372036854775808",

            "1e400",

            "1e-400",

            "NaN",

            "inf",

            "-inf",

        ] {

            assert!(

                parse_direction_corner(bad).is_err(),

                "numeric input {bad:?} parsed as a corner"

            );

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_corner_extremely_long_input_is_rejected_quickly() {

        let long = "a".repeat(1_000_000);

        assert!(parse_direction_corner(&long).is_err());

        let repeated = "right".repeat(200_000);

        assert!(parse_direction_corner(&repeated).is_err());

        // Deeply "nested" input: no recursion in the matcher, so no stack blowup.

        let nested = "(".repeat(100_000);

        assert!(parse_direction_corner(&nested).is_err());

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_corner_error_round_trips_through_owned() {

        let long = "top".repeat(10_000);

        for bad in ["", "bogus", "\u{1F600}", long.as_str()] {

            let Err(err) = parse_direction_corner(bad) else {

                panic!("{bad:?} unexpectedly parsed");

            };

            let owned = err.to_contained();

            assert_eq!(owned.to_shared(), err);

        }

    }

    // ---- parse_direction (parser) -------------------------------------------

    #[cfg(feature = "parser")]

    #[test]

    fn parse_direction_empty_and_whitespace_only() {

        for empty in [

            "", " ", "   ", "\t", "\n", "\r\n", "\t \n \r", "\u{a0}", "\u{3000}",

        ] {

            assert!(

                matches!(

                    parse_direction(empty),

                    Err(CssDirectionParseError::Error(_))

                ),

                "whitespace input {empty:?} did not yield Error"

            );

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_direction_valid_minimal_angles() {

        assert_eq!(

            parse_direction("45deg").unwrap(),

            Direction::Angle(AngleValue::deg(45.0))

        );

        // A bare number is degrees.

        assert_eq!(

            parse_direction("0").unwrap(),

            Direction::Angle(AngleValue::deg(0.0))

        );

        assert_eq!(

            parse_direction("1.5rad").unwrap(),

            Direction::Angle(AngleValue::rad(1.5))

        );

        assert_eq!(

            parse_direction("100grad").unwrap(),

            Direction::Angle(AngleValue::grad(100.0))

        );

        assert_eq!(

            parse_direction("50%").unwrap(),

            Direction::Angle(AngleValue::percent(50.0))

        );

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_direction_all_corner_spellings() {

        let cases = [

            ("to right", DirectionCorner::Right),

            ("to left", DirectionCorner::Left),

            ("to top", DirectionCorner::Top),

            ("to bottom", DirectionCorner::Bottom),

            ("to top right", DirectionCorner::TopRight),

            ("to right top", DirectionCorner::TopRight),

            ("to top left", DirectionCorner::TopLeft),

            ("to left top", DirectionCorner::TopLeft),

            ("to bottom right", DirectionCorner::BottomRight),

            ("to right bottom", DirectionCorner::BottomRight),

            ("to bottom left", DirectionCorner::BottomLeft),

            ("to left bottom", DirectionCorner::BottomLeft),

        ];

        for (input, dir_to) in cases {

            let parsed = parse_direction(input).unwrap();

            assert_eq!(parsed, canonical(dir_to), "input {input:?}");

            // Invariant: a parsed FromTo always starts at the opposite corner.

            let Direction::FromTo(ft) = parsed else {

                panic!("{input:?} did not parse to FromTo");

            };

            assert_eq!(ft.dir_from, ft.dir_to.opposite());

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_direction_surrounding_whitespace_is_ignored() {

        let expect = canonical(DirectionCorner::Right);

        for input in ["to right", "  to right  ", "\tto\nright\r", "to    right"] {

            assert_eq!(parse_direction(input).unwrap(), expect, "input {input:?}");

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_direction_error_classification() {

        assert!(matches!(

            parse_direction(""),

            Err(CssDirectionParseError::Error(_))

        ));

        // Missing "to" keyword.

        assert!(matches!(

            parse_direction("right"),

            Err(CssDirectionParseError::InvalidArguments(_))

        ));

        // "to" with no corner.

        assert!(matches!(

            parse_direction("to"),

            Err(CssDirectionParseError::InvalidArguments(_))

        ));

        // Too many components (checked before the corners are parsed).

        assert!(matches!(

            parse_direction("to top right bottom"),

            Err(CssDirectionParseError::InvalidArguments(_))

        ));

        // Unknown corner.

        assert!(matches!(

            parse_direction("to center"),

            Err(CssDirectionParseError::CornerError(

                CssDirectionCornerParseError::InvalidDirection("center")

            ))

        ));

        // Non-combinable corner pairs.

        for bad in [

            "to top top",

            "to top bottom",

            "to bottom top",

            "to left right",

            "to right left",

            "to left left",

        ] {

            assert!(

                matches!(

                    parse_direction(bad),

                    Err(CssDirectionParseError::InvalidArguments(_))

                ),

                "input {bad:?} was accepted or misclassified"

            );

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_direction_is_case_sensitive() {

        // NOTE: CSS keywords are case-insensitive; this parser is not. Asserting

        // the current (stricter) behavior so a future relaxation is a visible change.

        for bad in ["TO RIGHT", "To Right", "to RIGHT", "TO right", "45DEG"] {

            assert!(parse_direction(bad).is_err(), "{bad:?} was accepted");

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_direction_leading_trailing_junk_is_rejected() {

        for bad in [

            "45deg;",

            "45deg;garbage",

            "to right;",

            "to;right",

            "to right)",

            "(45deg)",

            "to right,",

            "-->45deg",

        ] {

            assert!(parse_direction(bad).is_err(), "{bad:?} was accepted");

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_direction_ignores_tokens_after_a_leading_angle() {

        // Leniency: once the first token parses as an angle, the rest of the

        // input is dropped on the floor instead of being rejected.

        let expect = Direction::Angle(AngleValue::deg(45.0));

        assert_eq!(parse_direction("45deg garbage").unwrap(), expect);

        assert_eq!(parse_direction("45deg to right").unwrap(), expect);

        assert_eq!(parse_direction("45deg 90deg").unwrap(), expect);

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_direction_garbage_and_unicode_do_not_panic() {

        for bad in [

            "!@#$%^&*()",

            "\u{0}",

            "\u{1F600}",

            "to \u{1F600}",

            "45\u{00b0}", // degree sign, not a CSS unit

            "to right\u{200b}",

            "\u{feff}to right",

            "ｔｏ right",

            "to\u{200b}right",

            "\u{202e}to right",

            "deg",

            "%",

            "-",

            "+",

            ".",

            "e",

            "todeg",

        ] {

            // Must never panic; whatever comes back must be a well-formed value.

            match parse_direction(bad) {

                Ok(Direction::Angle(a)) => {

                    assert!(a.to_degrees().is_finite(), "{bad:?} -> non-finite angle");

                }

                Ok(Direction::FromTo(ft)) => {

                    assert_eq!(ft.dir_from, ft.dir_to.opposite(), "{bad:?}");

                }

                Err(_) => {}

            }

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_direction_unicode_whitespace_separator_is_wellformed() {

        // U+00A0 is Unicode White_Space (so `split_whitespace` splits on it) but

        // is NOT CSS whitespace. Accept either outcome; just pin down that the

        // result can't be some third thing.

        if let Ok(d) = parse_direction("to\u{a0}right") {

            assert_eq!(d, canonical(DirectionCorner::Right));

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_direction_boundary_numbers_never_yield_nan_or_inf() {

        for input in [

            "0",

            "-0",

            "0deg",

            "-0deg",

            "360deg",

            "-360deg",

            "9223372036854775807",