//! Box model geometry types and writing-mode support for the layout solver.

//!

//! Provides edge-size types (`EdgeSizes`, `ResolvedBoxProps`, `PackedBoxProps`),

//! CSS value resolution (`UnresolvedMargin`, `UnresolvedEdge`, `ResolutionParams`),

//! intrinsic sizing (`IntrinsicSizes`), and writing-mode context (`WritingModeContext`).

use azul_core::{

    geom::{LogicalPosition, LogicalRect, LogicalSize},

    ui_solver::ResolvedOffsets,

};

use azul_css::props::{

    basic::{pixel::PixelValue, PhysicalSize, PropertyContext, ResolutionContext, SizeMetric},

    layout::LayoutWritingMode,

    style::{StyleDirection, StyleTextOrientation},

};

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

pub struct PositionedRectangle {

    /// The outer bounds of the rectangle

    pub bounds: LogicalRect,

    /// Margin of the rectangle.

    pub margin: ResolvedOffsets,

    /// Border widths of the rectangle.

    pub border: ResolvedOffsets,

    /// Padding of the rectangle.

    pub padding: ResolvedOffsets,

}

// +spec:box-model:83b3b8 - Box dimensions: content area with optional padding, border, margin areas

/// Represents the four edges of a box for properties like margin, padding, border.

// +spec:box-model:3b155c - "4 values assigned to sides" pattern (top, right, bottom, left) matching margin/inset shorthands

// +spec:width-calculation:37f9e7 - CSS 2.2 §8.1 box dimensions: content, padding, border, margin areas with top/right/bottom/left segments

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

pub struct EdgeSizes {

    pub top: f32,

    pub right: f32,

    pub bottom: f32,

    pub left: f32,

}

impl EdgeSizes {

    /// Sum of horizontal edges (left + right).

    /// Sum of vertical edges (top + bottom).

    // +spec:block-formatting-context:440282 - vertical writing modes use analogous layout via main/cross axis abstraction

    // +spec:block-formatting-context:a49f9e - line-relative directions mapped via writing mode

    // +spec:block-formatting-context:387117 - writing-mode property maps block flow to vertical/horizontal axes

    // +spec:box-model:4c01a3 - dimensional mapping: main=block axis, cross=inline axis per writing mode

    // +spec:box-model:4c1a9f - physical-to-logical mapping of margin/padding/border for vertical writing modes

    // +spec:box-model:9414ab - flow-relative mapping of box edges (margin/padding/border) per writing mode

    // +spec:inline-formatting-context:2de457 - block/inline dimension mapping via writing mode

    // +spec:inline-formatting-context:c6b91e - line-relative "over"/"under" mapped to physical top/bottom via writing mode

    // +spec:writing-modes:00a918 - Abstract-to-physical mappings for block/inline to top/right/bottom/left

    // +spec:writing-modes:14e6f0 - block-start/end depend only on writing-mode; inline-start/end also depend on direction (handled in positioning.rs)

    // +spec:writing-modes:1c2101 - Abstract directional terms (top/right/bottom/left) to logical axes (main/cross) based on writing-mode

    // +spec:writing-modes:1c5155 - line-relative mappings: over/under/line-left/line-right → top/bottom/left/right in horizontal-tb

    // +spec:writing-modes:70daf1 - block/inline axis mapping per writing-mode for edge sizes

    // +spec:writing-modes:f9af71 - flow-relative directions: block-start/end and inline-start/end mapped to physical edges

    // +spec:writing-modes:60b023 - abstract-to-physical mapping: block axis = main, inline axis = cross

    // +spec:writing-modes:829cd7 - flow-relative directions: block-start/end from writing-mode, inline-start/end from writing-mode+direction

    // +spec:writing-modes:a2113d - block/inline axis mapping for writing modes (block-axis, inline-axis, block-start/end, inline-start/end)

    // +spec:writing-modes:c0ae9c - abstract directional mappings from writing-mode/direction

    // +spec:writing-modes:c91130 - Abstract box terminology: block/inline axis mapping per writing-mode

    // +spec:writing-modes:cd31ce - flow-relative directions mapped to physical via writing mode

    // +spec:writing-modes:fd8c18 - block/inline axis mapping based on writing mode

    // +spec:writing-modes:0e549a - writing-mode computed value influences physical/logical axis mapping

    /// Returns the size of the edge at the start of the main/block axis.

        }

    /// Returns the size of the edge at the end of the main/block axis.

        }

    /// Returns the sum of the start and end sizes on the main/block axis.

    // +spec:block-formatting-context:6225cb - line-relative directions: vertical modes map line-over/under to top/bottom

    /// Returns the size of the edge at the start of the cross/inline axis.

        }

    /// Returns the size of the edge at the end of the cross/inline axis.

        }

    /// Returns the sum of the start and end sizes on the cross/inline axis.

    // +spec:block-formatting-context:a49f9e - line-over/line-under are line-relative

    //   block-axis edges: top/bottom in horizontal-tb, right/left in vertical modes.

    // +spec:inline-formatting-context:c6b91e - line-relative "over"/"under" mapped to

    //   physical edges via writing mode.

    // +spec:writing-modes:1c5155 - line-relative mappings for over/under.

    /// Returns the line-over edge (line-relative block-axis start).

    ///

    /// Per CSS Writing Modes L4 §6.3, the line-over side is `top` in

    /// `horizontal-tb` and `right` in both vertical writing modes. Unlike

    /// [`Self::main_start`] (a physical block-axis accessor), this is the

    /// *line-relative* over side and coincides with `main_start` only in

    /// `horizontal-tb`.

        }

    /// Returns the line-under edge (line-relative block-axis end).

    ///

    /// Per CSS Writing Modes L4 §6.3, the line-under side is `bottom` in

    /// `horizontal-tb` and `left` in both vertical writing modes.

        }

    /// Returns the sum of the line-over and line-under edges.

    // +spec:writing-modes:829cd7 - inline-start/end depend on writing-mode AND direction.

    // +spec:writing-modes:c0ae9c - flow-relative inline mappings derive from

    //   writing-mode + direction (RTL's inline-start = line-right).

    // +spec:writing-modes:14e6f0 - inline-start/end depend on direction as well as wm.

    /// Returns the flow-relative inline-start edge.

    ///

    /// The inline-start side is `line-left` (see [`Self::cross_start`]) when the

    /// inline base direction is LTR, and `line-right` (see [`Self::cross_end`])

    /// when it is RTL. This is the direction-aware counterpart that

    /// `cross_start`/`cross_end` (which are direction-blind line-left/line-right)

    /// cannot express on their own.

        }

    /// Returns the flow-relative inline-end edge.

    ///

    /// The inline-end side is `line-right` when the inline base direction is

    /// LTR, and `line-left` when it is RTL.

        }

    /// Returns the sum of the inline-start and inline-end edges.

    ///

    /// Direction-independent (start + end covers the whole inline axis), but

    /// takes `dir` for call-site symmetry with the individual accessors.

}

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

// UNRESOLVED VALUE TYPES (for lazy resolution during layout)

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

/// An unresolved CSS margin value.

// +spec:box-model:ff1730 - margin properties apply to both continuous and paged media

///

/// Margins can be `auto` (for centering) or a length value that needs

/// resolution against the containing block.

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

pub enum UnresolvedMargin {

    /// margin: 0 (default)

    #[default]

    Zero,

    /// margin: auto (for centering, CSS 2.2 § 10.3.3)

    Auto,

    /// A length value (px, %, em, vh, etc.)

    Length(PixelValue),

}

impl UnresolvedMargin {

    /// Returns true if this is an auto margin

    /// Resolve this margin value to pixels.

    ///

    /// - `Auto` returns 0.0 (actual auto margin calculation happens in layout)

    /// - `Zero` returns 0.0

    /// - `Length` is resolved using the resolution context

    #[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

            // +spec:box-model:c921aa - auto margin-top/bottom used value is 0 for block-level non-replaced elements in normal flow

            // +spec:box-model:e25fdc - auto margins treated as zero for abspos size computation

        }

}

/// Unresolved edge sizes for margin/padding/border.

///

/// This stores the raw CSS values before resolution, allowing us to

/// defer resolution until the containing block size is known.

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

pub struct UnresolvedEdge<T> {

    pub top: T,

    pub right: T,

    pub bottom: T,

    pub left: T,

}

impl<T> UnresolvedEdge<T> {

}

impl UnresolvedEdge<UnresolvedMargin> {

    /// Resolve all margin edges to pixel values.

    /// Extract which margins are set to `auto`.

}

impl UnresolvedEdge<PixelValue> {

    /// Resolve all edges to pixel values.

}

/// Parameters needed to resolve CSS values to pixels.

#[derive(Debug, Clone, Copy)]

pub struct ResolutionParams {

    // +spec:inline-formatting-context:26c933 - LogicalSize maps inline/block dimensions to physical width/height per writing mode

    /// The containing block size (for % resolution)

    pub containing_block: LogicalSize,

    /// The viewport size (for vh/vw resolution)

    pub viewport_size: LogicalSize,

    /// The element's computed font-size (for em resolution)

    pub element_font_size: f32,

    /// The root element's font-size (for rem resolution)

    pub root_font_size: f32,

}

impl ResolutionParams {

    /// Create a `ResolutionContext` from these parameters.

}

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

// UNRESOLVED BOX PROPS (new design)

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

/// Box properties with unresolved CSS values.

///

/// This stores the raw CSS values as parsed, deferring resolution until

/// layout time when the containing block size is known.

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

pub struct UnresolvedBoxProps {

    pub margin: UnresolvedEdge<UnresolvedMargin>,

    pub padding: UnresolvedEdge<PixelValue>,

    pub border: UnresolvedEdge<PixelValue>,

    /// css-writing-modes-4 §7.2: margin/padding percentages resolve against

    /// the containing block's INLINE size. Captured at collection time from

    /// the node's writing mode so late re-resolution (`resolve_box_props` with

    /// the real containing block) picks the right axis without re-reading

    /// the cascade.

    pub vertical_writing_mode: bool,

}

impl UnresolvedBoxProps {

    /// Resolve all box properties to pixel values.

}

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

// RESOLVED BOX PROPS (legacy name: BoxProps)

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

/// Tracks which margins are set to `auto` (for centering calculations).

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

#[allow(clippy::struct_excessive_bools)] // one independent bool per margin edge (auto flags)

pub struct MarginAuto {

    pub left: bool,

    pub right: bool,

    pub top: bool,

    pub bottom: bool,

}

/// A fully resolved representation of a node's box model properties.

// +spec:box-model:3e083b - content/padding/border/margin box model layers

// +spec:box-model:a227ff - content/padding/border/margin edges defining box extents for overflow

// +spec:containing-block:bca691 - box model edges: padding/border/margin boxes with content-box, padding-box, margin-box methods

///

/// All values are in pixels. This is the result of resolving `UnresolvedBoxProps`

/// against a containing block.

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

pub struct ResolvedBoxProps {

    pub margin: EdgeSizes,

    pub padding: EdgeSizes,

    pub border: EdgeSizes,

    /// Tracks which margins are set to `auto`.

    /// CSS 2.2 § 10.3.3: If both margin-left and margin-right are auto,

    /// their used values are equal, centering the element within its container.

    pub margin_auto: MarginAuto,

}

impl ResolvedBoxProps {

    // +spec:box-model:be08c6 - inner size (content-box) from outer size minus border+padding, floored at zero

    // +spec:writing-modes:a58616 - abstract dimensions: inline size maps to physical width/height per writing-mode

    /// Calculates the inner content-box size from an outer border-box size,

    /// correctly accounting for the specified writing mode.

        // The sum of padding and border along the cross (inline) axis.

        // The sum of padding and border along the main (block) axis.

        // +spec:box-model:2589b1 - content size = border-box - border - padding, floored at zero

        // +spec:box-model:3ab53d - if padding+border > border-box, content floors at 0px

    // +spec:box-model:aa585e - Content/padding/border/margin edge relationships

    // +spec:height-calculation:6c9abb - box model edges: margin > border > padding > content

    /// Returns the content-box rect from a border-box rect.

    /// Shrinks inward by border + padding on each side.

    // +spec:box-model:1720a5 - content of a block box is confined to its content edges

    /// Returns the padding-box rect from a border-box rect.

    /// Shrinks inward by border on each side.

    /// Returns the margin-box rect from a border-box rect.

    /// Expands outward by margin on each side.

    // +spec:box-model:0e75c1 - margin, padding, border contribute to layout bounds (default line-fit-edge: leading uses line-height model)

    /// Total horizontal space consumed by margin + border + padding.

    /// Total vertical space consumed by margin + border + padding.

    /// Total horizontal space consumed by border + padding only (no margin).

    /// Total vertical space consumed by border + padding only (no margin).

}

/// Type alias for backwards compatibility.

/// TODO: Remove this once all code uses `ResolvedBoxProps` directly.

pub type BoxProps = ResolvedBoxProps;

/// Packed representation of box model properties using i16×10 encoding.

///

/// Stores margin/padding/border as i16 values scaled by 10 (0.1px precision),

/// reducing the hot struct from 52B to 26B. Range: ±3276.7px per edge.

///

/// Only used for storage in `LayoutNodeHot`. The layout solver unpacks to

/// `ResolvedBoxProps` (f32) for computation.

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

#[repr(C)]

pub struct PackedBoxProps {

    pub margin: [i16; 4],     // top, right, bottom, left — ×10

    pub padding: [i16; 4],    // ×10

    pub border: [i16; 4],     // ×10

    pub margin_auto: MarginAuto,

}

impl PackedBoxProps {

    /// Pack a `ResolvedBoxProps` into compact i16×10 encoding.

    #[inline]

    /// Unpack to full `ResolvedBoxProps` with f32 values.

    #[inline]

    /// Convenience: unpack and call `inner_size` on the result.

    #[inline]

    /// Convenience: unpack and call `content_box` on the result.

    #[inline]

    /// Convenience: unpack and call `padding_box` on the result.

    #[inline]

    /// Convenience: unpack and call `margin_box` on the result.

    #[inline]

    /// Convenience: unpack and return horizontal MBP.

    #[inline]

    /// Convenience: unpack and return vertical MBP.

    #[inline]

    /// Convenience: unpack and return horizontal BP.

    #[inline]

    /// Convenience: unpack and return vertical BP.

    #[inline]

    #[inline]

    #[allow(clippy::cast_possible_truncation)] // bounded graphics/coord/counter/fixed-point cast

        const MIN: f32 = i16::MIN as f32;

        const MAX: f32 = i16::MAX as f32;

    #[inline]

    #[allow(clippy::trivially_copy_pass_by_ref)] // <=8B Copy param kept by-ref intentionally (hot pixel/coord path or to avoid churning call sites for a perf-neutral change)

}

// Re-export float and clear types from azul_css

pub use azul_css::props::layout::{LayoutClear, LayoutFloat};

// +spec:intrinsic-sizing:af39b6 - min-content, max-content, and stretch fit size definitions

// min-content constraint, max-content constraint definitions

// and fit-content sizes for both inline and block axes

// +spec:height-calculation:e9ec84 - replaced elements have natural dimensions (width, height, ratio)

/// Represents the intrinsic sizing information for an element, calculated

/// without knowledge of the final containing block size.

// +spec:intrinsic-sizing:127a10 - min-content, max-content, fit-content size definitions (css-sizing-3 §2.1)

// +spec:intrinsic-sizing:21f2cb - defines min-content, max-content, and stretch-fit size terminology

// +spec:width-calculation:1583c4 - min-content, max-content, fit-content intrinsic size definitions (§2.1)

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

pub struct IntrinsicSizes {

    // +spec:width-calculation:b83d0a - min-content width ("preferred minimum width" in CSS2.1§10.3.5)

    // +spec:writing-modes:1583c4 - min-content size in inline axis = size fitting contents with all soft wraps taken

    /// §2.1 min-content inline size: inline size fitting contents if all soft wraps taken.

    pub min_content_width: f32,

    // +spec:width-calculation:0c74d3 - max-content width ("preferred width" in CSS2.1§10.3.5)

    // +spec:writing-modes:6e85d3 - max-content inline size is the "ideal" size in the inline axis (writing-mode-dependent)

    /// §2.1 max-content inline size: narrowest inline size if no soft wraps taken.

    pub max_content_width: f32,

    /// The width specified by CSS properties, if any.

    pub preferred_width: Option<f32>,

    /// §2.1 min-content block size: for block containers, tables, and inline boxes,

    /// equivalent to max-content block size.

    pub min_content_height: f32,

    // +spec:writing-modes:8c94e2 - max-content block size is the "ideal" block size after layout

    /// §2.1 max-content block size: "ideal" block size, usually content height after layout.

    pub max_content_height: f32,

    /// The height specified by CSS properties, if any.

    pub preferred_height: Option<f32>,

    // +spec:intrinsic-sizing:af39b6 - natural (intrinsic) aspect ratio of a replaced element

    // +spec:height-calculation:e9ec84 - replaced-element natural width/height/ratio

    /// The element's natural aspect ratio (inline / block), if it has one — e.g. a

    /// replaced element with intrinsic dimensions. `None` for non-replaced content.

    pub preferred_aspect_ratio: Option<f32>,

}

impl IntrinsicSizes {

    // +spec:intrinsic-sizing:127a10 - fit-content = clamp(min-content, stretch-fit, max-content)

    // +spec:intrinsic-sizing:21f2cb - stretch-fit size drawn from available (containing-block) space

    /// CSS Sizing §2.1 fit-content **inline** size:

    /// `clamp(min-content, stretch-fit, max-content)`, where the stretch-fit size is the

    /// `available_inline_size` (the space the containing block offers in the inline axis).

    /// Equal to `max(min_content, min(stretch_fit, max_content))`.

    #[must_use]

    /// CSS Sizing §2.1 fit-content **block** size:

    /// `clamp(min-content, stretch-fit, max-content)` in the block axis.

    #[must_use]

}

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

// WRITING MODE SUPPORT

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

/// Captures the resolved writing mode context for a node.

///

/// This struct bundles together all the CSS properties that affect how

/// logical directions (inline/block) map to physical directions (x/y).

/// Spec agents should use this struct to implement writing-mode-aware layout.

///

/// # CSS Writing Modes Level 4

///

/// - `writing-mode` determines the block flow direction and inline base direction

/// - `direction` determines the inline base direction (ltr or rtl)

/// - `text-orientation` determines glyph orientation in vertical writing modes

// +spec:block-formatting-context:333dcb - typographic mode captured by text_orientation field

// +spec:block-formatting-context:66eb6d - text-orientation property (mixed|upright|sideways) integrated into WritingModeContext

// +spec:block-formatting-context:8be1b0 - writing modes and vertical text orientation context (UTN#22)

// +spec:display-property:0a39dc - text-orientation affects inline-level alignment via WritingModeContext

// +spec:display-property:591355 - bidirectionality support via direction property in WritingModeContext

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

pub struct WritingModeContext {

    pub writing_mode: LayoutWritingMode,

    pub direction: StyleDirection,

    // +spec:block-formatting-context:925cfe - text-orientation mixed/upright for horizontal scripts in vertical mode

    pub text_orientation: StyleTextOrientation,

}

impl Default for WritingModeContext {

}

impl WritingModeContext {

    /// Constructs a `WritingModeContext`, applying spec-mandated overrides.

    // +spec:writing-modes:8307e4 - text-orientation: upright forces used direction to ltr

        // CSS Writing Modes Level 4 §5.1: text-orientation: upright causes

        // the used value of direction to be ltr, and all characters to be

        // treated as strong LTR for bidi reordering purposes.

        } else {

        };

    // +spec:writing-modes:458d31 - text-orientation:upright forces used direction to ltr

    /// Returns the used value of `direction`.

    ///

    /// The upright override is already applied in `new()`, so this just

    /// returns the stored direction.

    // +spec:containing-block:c205e5 - orthogonal flow: child writing mode perpendicular to containing block's

    // +spec:block-formatting-context:6225cb - vertical writing modes: line-over is right, line-under is left

    // +spec:block-formatting-context:9a4269 - vertical vs horizontal script classification

    /// Returns true if the writing mode is horizontal (`HorizontalTb`).

    ///

    /// When true, the inline axis is horizontal and the block axis is vertical.

    /// Returns true if the inline size corresponds to the physical width.

    ///

    /// In horizontal writing modes, inline size = width.

    /// In vertical writing modes, inline size = height.

    // +spec:block-formatting-context:bb9845 - orthogonal flows: inline/block axis mapping

    /// Returns true if the block size corresponds to the physical height.

    ///

    /// In horizontal writing modes, block size = height.

    /// In vertical writing modes, block size = width.

    // +spec:writing-modes:32541a - direction property controls inline text direction via stylesheet

    /// Returns true if the inline direction is reversed (RTL in horizontal,

    /// or bottom-to-top in certain vertical modes).

}

#[cfg(test)]

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

mod autotest_generated {

    use super::*;

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

    /// All writing modes, so every mapping test can be run exhaustively.

    const ALL_WM: [LayoutWritingMode; 3] = [

        LayoutWritingMode::HorizontalTb,

        LayoutWritingMode::VerticalRl,

        LayoutWritingMode::VerticalLr,

    ];

    fn edges(top: f32, right: f32, bottom: f32, left: f32) -> EdgeSizes {

        EdgeSizes { top, right, bottom, left }

    }

    fn rect(x: f32, y: f32, w: f32, h: f32) -> LogicalRect {

        LogicalRect {

            origin: LogicalPosition { x, y },

            size: LogicalSize { width: w, height: h },

        }

    }

    /// `EdgeSizes`/`ResolvedBoxProps` carry no `PartialEq`, and the packed

    /// encoding is lossy by design, so float comparisons need a tolerance.

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

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

    }

    fn params(cb: LogicalSize, vp: LogicalSize, font: f32, root: f32) -> ResolutionParams {

        ResolutionParams {

            containing_block: cb,

            viewport_size: vp,

            element_font_size: font,

            root_font_size: root,

        }

    }

    /// 800x600 containing block, 1000x500 viewport, 16px element / 10px root font.

    /// Every dimension is distinct so a transposed axis cannot pass by accident.

    fn distinct_params() -> ResolutionParams {

        params(

            LogicalSize::new(800.0, 600.0),

            LogicalSize::new(1000.0, 500.0),

            16.0,

            10.0,

        )

    }

    fn props(margin: EdgeSizes, padding: EdgeSizes, border: EdgeSizes) -> ResolvedBoxProps {

        ResolvedBoxProps { margin, padding, border, margin_auto: MarginAuto::default() }

    }

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

    // EdgeSizes: sums

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

    #[test]

    fn edge_sizes_sums_pick_the_right_pair_of_edges() {

        let e = edges(1.0, 2.0, 4.0, 8.0); // top, right, bottom, left

        assert_eq!(e.horizontal_sum(), 10.0, "horizontal = left + right");

        assert_eq!(e.vertical_sum(), 5.0, "vertical = top + bottom");

    }

    #[test]

    fn edge_sizes_default_is_all_zero() {

        let e = EdgeSizes::default();

        assert_eq!(e.horizontal_sum(), 0.0);

        assert_eq!(e.vertical_sum(), 0.0);

        for wm in ALL_WM {

            assert_eq!(e.main_sum(wm), 0.0);

            assert_eq!(e.cross_sum(wm), 0.0);

        }

    }

    #[test]

    fn edge_sizes_sums_saturate_to_infinity_instead_of_panicking() {

        // f32::MAX + f32::MAX overflows to +inf; it must not panic or wrap.

        let e = edges(f32::MAX, f32::MAX, f32::MAX, f32::MAX);

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

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

    }

    #[test]

    fn edge_sizes_opposing_infinities_produce_nan_not_a_panic() {

        // inf + (-inf) is NaN by IEEE-754. The point is that it is deterministic

        // and does not trap — nothing downstream may assume a finite sum.

        let e = edges(f32::INFINITY, f32::INFINITY, f32::NEG_INFINITY, f32::NEG_INFINITY);

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

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

    }

    #[test]

    fn edge_sizes_nan_edges_propagate_without_panicking() {

        let e = edges(f32::NAN, 1.0, 2.0, 3.0);

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

        assert_eq!(e.horizontal_sum(), 4.0, "a NaN top must not poison left+right");

        for wm in ALL_WM {

            let _ = e.main_sum(wm);

            let _ = e.cross_sum(wm);

        }

    }

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

    // EdgeSizes: writing-mode axis mapping

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

    #[test]

    fn edge_sizes_axis_mapping_is_exact_for_every_writing_mode() {

        let e = edges(1.0, 2.0, 4.0, 8.0); // top, right, bottom, left

        // horizontal-tb: block (main) axis is vertical, inline (cross) axis is horizontal.

        let h = LayoutWritingMode::HorizontalTb;

        assert_eq!(e.main_start(h), 1.0, "main-start = top");

        assert_eq!(e.main_end(h), 4.0, "main-end = bottom");

        assert_eq!(e.cross_start(h), 8.0, "cross-start = left");

        assert_eq!(e.cross_end(h), 2.0, "cross-end = right");

        // vertical-*: block (main) axis is horizontal, inline (cross) axis is vertical.

        for wm in [LayoutWritingMode::VerticalRl, LayoutWritingMode::VerticalLr] {

            assert_eq!(e.main_start(wm), 8.0, "main-start = left");

            assert_eq!(e.main_end(wm), 2.0, "main-end = right");

            assert_eq!(e.cross_start(wm), 1.0, "cross-start = top");

            assert_eq!(e.cross_end(wm), 4.0, "cross-end = bottom");

        }

    }

    // +spec:block-formatting-context:a49f9e - line-over/line-under accessors.

    #[test]

    fn edge_sizes_line_over_under_is_line_relative_not_physical() {

        let e = edges(1.0, 2.0, 4.0, 8.0); // top, right, bottom, left

        // horizontal-tb: over = top, under = bottom (coincides with main_start/end).

        let h = LayoutWritingMode::HorizontalTb;

        assert_eq!(e.line_over(h), 1.0, "line-over = top in horizontal-tb");

        assert_eq!(e.line_under(h), 4.0, "line-under = bottom in horizontal-tb");

        assert_eq!(e.line_over(h), e.main_start(h), "over == main-start only in horizontal-tb");

        // vertical modes: over = right, under = left (CSS Writing Modes L4 §6.3).

        // Crucially this differs from main_start/main_end (left/right), proving the

        // line-relative accessor is not just an alias of the physical block axis.

        for wm in [LayoutWritingMode::VerticalRl, LayoutWritingMode::VerticalLr] {

            assert_eq!(e.line_over(wm), 2.0, "line-over = right in vertical modes");

            assert_eq!(e.line_under(wm), 8.0, "line-under = left in vertical modes");

            assert_ne!(e.line_over(wm), e.main_start(wm), "over != main-start in vertical modes");

        }

        // Sum picks the line-relative pair, independent of writing mode orientation.

        assert_eq!(e.line_over_under_sum(h), 5.0);

        assert_eq!(e.line_over_under_sum(LayoutWritingMode::VerticalRl), 10.0);

    }

    // +spec:writing-modes:829cd7 / c0ae9c - direction-aware inline-start/end accessors.

    #[test]

    fn edge_sizes_inline_start_end_depend_on_direction() {

        let e = edges(1.0, 2.0, 4.0, 8.0); // top, right, bottom, left

        for wm in ALL_WM {

            // LTR: inline-start = line-left = cross_start; inline-end = line-right = cross_end.

            assert_eq!(

                e.inline_start(wm, StyleDirection::Ltr),

                e.cross_start(wm),

                "LTR inline-start = cross-start (line-left)"

            );

            assert_eq!(

                e.inline_end(wm, StyleDirection::Ltr),

                e.cross_end(wm),

                "LTR inline-end = cross-end (line-right)"

            );

            // RTL: the two ends swap — inline-start moves to line-right.

            assert_eq!(

                e.inline_start(wm, StyleDirection::Rtl),

                e.cross_end(wm),

                "RTL inline-start = cross-end (line-right)"

            );

            assert_eq!(

                e.inline_end(wm, StyleDirection::Rtl),

                e.cross_start(wm),

                "RTL inline-end = cross-start (line-left)"

            );

            // The sum covers the whole inline axis regardless of direction.

            assert_eq!(

                e.inline_sum(wm, StyleDirection::Ltr),

                e.inline_sum(wm, StyleDirection::Rtl),

                "inline-sum is direction-independent"

            );

            assert_eq!(e.inline_sum(wm, StyleDirection::Ltr), e.cross_sum(wm));

        }

        // Concrete horizontal-tb values: LTR start=left(8), RTL start=right(2).

        let h = LayoutWritingMode::HorizontalTb;

        assert_eq!(e.inline_start(h, StyleDirection::Ltr), 8.0);

        assert_eq!(e.inline_start(h, StyleDirection::Rtl), 2.0);

    }

    #[test]

    fn edge_sizes_main_and_cross_sums_partition_the_four_edges() {

        // Whatever the writing mode, main+cross must account for each edge exactly

        // once — a transposition bug in one arm would break this identity.

        let e = edges(1.0, 2.0, 4.0, 8.0);

        for wm in ALL_WM {

            assert_eq!(e.main_start(wm) + e.main_end(wm), e.main_sum(wm));

            assert_eq!(e.cross_start(wm) + e.cross_end(wm), e.cross_sum(wm));

            assert_eq!(

                e.main_sum(wm) + e.cross_sum(wm),

                e.horizontal_sum() + e.vertical_sum(),

                "{wm:?}: main+cross must cover all four edges"

            );

        }

    }

    #[test]

    fn edge_sizes_axis_accessors_survive_extreme_values() {

        let e = edges(f32::MAX, f32::MIN, f32::INFINITY, f32::NEG_INFINITY);

        for wm in ALL_WM {

            let _ = e.main_start(wm);

            let _ = e.main_end(wm);

            let _ = e.cross_start(wm);

            let _ = e.cross_end(wm);

            let _ = e.main_sum(wm);

            let _ = e.cross_sum(wm);

        }

    }

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

    // UnresolvedMargin

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

    #[test]

    fn unresolved_margin_is_auto_only_for_the_auto_variant() {

        assert!(UnresolvedMargin::Auto.is_auto());

        assert!(!UnresolvedMargin::Zero.is_auto());

        assert!(!UnresolvedMargin::Length(PixelValue::const_px(10)).is_auto());

        // A zero-valued length is still *not* `auto`.

        assert!(!UnresolvedMargin::Length(PixelValue::zero()).is_auto());

        assert!(!UnresolvedMargin::default().is_auto(), "default is Zero, not Auto");

    }

    #[test]

    fn unresolved_margin_auto_and_zero_both_resolve_to_zero_px() {

        let ctx = distinct_params().to_resolution_context();

        assert_eq!(UnresolvedMargin::Zero.resolve(&ctx), 0.0);

        // `auto` is resolved later by the layout algorithm; here it must read as 0.

        assert_eq!(UnresolvedMargin::Auto.resolve(&ctx), 0.0);

    }

    #[test]

    fn unresolved_margin_length_resolves_by_metric() {

        let ctx = distinct_params().to_resolution_context(); // 800x600 cb, 16px font, 10px root

        let r = |pv: PixelValue| UnresolvedMargin::Length(pv).resolve(&ctx);

        assert_eq!(r(PixelValue::px(12.5)), 12.5);

        assert_eq!(r(PixelValue::em(2.0)), 32.0, "em = 2 x element font-size");

        assert_eq!(r(PixelValue::rem(2.0)), 20.0, "rem = 2 x root font-size");

    }

    #[test]

    fn unresolved_margin_percent_resolves_against_containing_block_width() {

        // CSS 2.1 §8.3: percentage margins ALWAYS refer to the containing block

        // *width* — never the height. With a 800x600 block, 50% must be 400, not 300.

        let ctx = distinct_params().to_resolution_context();

        let got = UnresolvedMargin::Length(PixelValue::percent(50.0)).resolve(&ctx);

        assert_eq!(got, 400.0);

        assert_ne!(got, 300.0, "percentage margin must not use the block height");

    }

    #[test]

    fn unresolved_margin_nan_length_resolves_to_zero_not_nan() {

        // PixelValue stores a fixed-point isize, and `f32 as isize` saturates NaN

        // to 0 — so a NaN can never escape into layout as a NaN margin.

        let ctx = distinct_params().to_resolution_context();

        let got = UnresolvedMargin::Length(PixelValue::px(f32::NAN)).resolve(&ctx);

        assert!(!got.is_nan(), "a NaN px value must not survive resolution");

        assert_eq!(got, 0.0);

    }

    #[test]

    fn unresolved_margin_huge_length_saturates_to_a_finite_value() {

        let ctx = distinct_params().to_resolution_context();

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

            let got = UnresolvedMargin::Length(PixelValue::px(v)).resolve(&ctx);

            assert!(got.is_finite(), "px({v}) resolved to a non-finite {got}");

        }

    }

    #[test]

    fn unresolved_margin_percent_of_a_nan_containing_block_is_nan_not_a_panic() {

        // The containing block is a raw f32 and is NOT sanitized, so a NaN block

        // size *does* propagate. Documenting the real behaviour: deterministic NaN,

        // no panic — the guard has to live at the caller, not here.

        let p = params(

            LogicalSize::new(f32::NAN, f32::NAN),

            LogicalSize::new(1000.0, 500.0),

            16.0,

            10.0,

        );

        let got = UnresolvedMargin::Length(PixelValue::percent(50.0)).resolve(&p.to_resolution_context());

        assert!(got.is_nan());

    }

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

    // UnresolvedEdge

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

    #[test]

    fn unresolved_edge_new_assigns_fields_in_top_right_bottom_left_order() {

        // The classic CSS shorthand transposition bug: argument order is TRBL.

        let e = UnresolvedEdge::new(1_u8, 2, 4, 8);

        assert_eq!(e.top, 1);

        assert_eq!(e.right, 2);

        assert_eq!(e.bottom, 4);

        assert_eq!(e.left, 8);

    }

    #[test]

    fn unresolved_edge_new_accepts_extreme_payloads() {

        let e = UnresolvedEdge::new(f32::NAN, f32::INFINITY, f32::MAX, f32::MIN);

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

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

        assert_eq!(e.bottom, f32::MAX);

        assert_eq!(e.left, f32::MIN);

    }

    #[test]

    fn get_margin_auto_flags_exactly_the_auto_sides() {

        let e = UnresolvedEdge::new(

            UnresolvedMargin::Zero,                                 // top

            UnresolvedMargin::Auto,                                 // right

            UnresolvedMargin::Length(PixelValue::const_px(5)),      // bottom

            UnresolvedMargin::Auto,                                 // left

        );

        let a = e.get_margin_auto();

        assert!(!a.top);

        assert!(a.right);

        assert!(!a.bottom);

        assert!(a.left);

    }

    #[test]

    fn get_margin_auto_on_default_edge_flags_nothing() {

        let a = UnresolvedEdge::<UnresolvedMargin>::default().get_margin_auto();

        assert!(!a.top && !a.right && !a.bottom && !a.left);

    }

    #[test]

    fn unresolved_margin_edge_resolve_keeps_each_side_separate() {

        let ctx = distinct_params().to_resolution_context();

        let e = UnresolvedEdge::new(

            UnresolvedMargin::Length(PixelValue::px(1.0)),   // top

            UnresolvedMargin::Length(PixelValue::px(2.0)),   // right

            UnresolvedMargin::Auto,                          // bottom -> 0

            UnresolvedMargin::Length(PixelValue::px(8.0)),   // left

        );

        let r = e.resolve(&ctx);

        assert_eq!(r.top, 1.0);

        assert_eq!(r.right, 2.0);

        assert_eq!(r.bottom, 0.0, "auto resolves to 0 px here");

        assert_eq!(r.left, 8.0);

    }

    #[test]

    fn pixel_edge_resolve_drops_percentages_on_border_width() {

        // CSS Backgrounds 3 §4.1: `%` is not a valid border-width. The resolver

        // must yield 0 rather than silently resolving against the containing block.

        let ctx = distinct_params().to_resolution_context();

        let e = UnresolvedEdge::new(

            PixelValue::percent(50.0),

            PixelValue::percent(50.0),

            PixelValue::percent(50.0),

            PixelValue::percent(50.0),

        );

        let r = e.resolve(&ctx, PropertyContext::BorderWidth);

        assert_eq!(r.top, 0.0);

        assert_eq!(r.right, 0.0);

        assert_eq!(r.bottom, 0.0);

        assert_eq!(r.left, 0.0);

    }

    #[test]

    fn pixel_edge_resolve_uses_block_width_for_vertical_padding_percentages() {

        // CSS 2.1 §8.4: padding-top/bottom percentages also refer to the containing

        // block WIDTH. With 800x600, every side must land on 80, never 60.

        let ctx = distinct_params().to_resolution_context();

        let e = UnresolvedEdge::new(

            PixelValue::percent(10.0),

            PixelValue::percent(10.0),

            PixelValue::percent(10.0),

            PixelValue::percent(10.0),

        );

        let r = e.resolve(&ctx, PropertyContext::Padding);

        assert_eq!(r.top, 80.0, "padding-top % must use the width");

        assert_eq!(r.bottom, 80.0, "padding-bottom % must use the width");

        assert_eq!(r.left, 80.0);

        assert_eq!(r.right, 80.0);

    }

    #[test]

    fn pixel_edge_resolve_of_viewport_units_uses_the_viewport_not_the_block() {

        let ctx = distinct_params().to_resolution_context(); // viewport 1000x500

        let e = UnresolvedEdge::new(

            PixelValue::from_metric(SizeMetric::Vw, 10.0),

            PixelValue::from_metric(SizeMetric::Vh, 10.0),

            PixelValue::from_metric(SizeMetric::Vmin, 10.0),

            PixelValue::from_metric(SizeMetric::Vmax, 10.0),

        );

        let r = e.resolve(&ctx, PropertyContext::Padding);

        assert_eq!(r.top, 100.0, "10vw of 1000");

        assert_eq!(r.right, 50.0, "10vh of 500");

        assert_eq!(r.bottom, 50.0, "10vmin of min(1000,500)");

        assert_eq!(r.left, 100.0, "10vmax of max(1000,500)");

    }

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

    // ResolutionParams

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

    #[test]

    fn to_resolution_context_maps_every_field() {

        let ctx = distinct_params().to_resolution_context();

        assert_eq!(ctx.element_font_size, 16.0);

        assert_eq!(ctx.root_font_size, 10.0);

        assert_eq!(ctx.containing_block_size.width, 800.0);

        assert_eq!(ctx.containing_block_size.height, 600.0);

        assert_eq!(ctx.viewport_size.width, 1000.0);

        assert_eq!(ctx.viewport_size.height, 500.0);

        assert!(ctx.element_size.is_none(), "element size is unknown pre-layout");

    }

    #[test]

    fn to_resolution_context_aliases_parent_font_size_onto_the_element_font_size() {

        // Documented quirk: for non-font properties `em` resolves against the

        // element's OWN font-size, so the context deliberately reports

        // parent == element. Using it for font-size resolution would be wrong.

        let ctx = distinct_params().to_resolution_context();

        assert_eq!(ctx.parent_font_size, ctx.element_font_size);

        assert_eq!(ctx.parent_font_size, 16.0);

    }

    #[test]

    fn to_resolution_context_passes_extreme_values_through_unchanged() {

        let p = params(

            LogicalSize::new(f32::MAX, f32::NAN),

            LogicalSize::new(f32::INFINITY, 0.0),

            0.0,

            f32::MIN,

        );

        let ctx = p.to_resolution_context();

        assert_eq!(ctx.containing_block_size.width, f32::MAX);

        assert!(ctx.containing_block_size.height.is_nan());

        assert!(ctx.viewport_size.width.is_infinite());

        assert_eq!(ctx.element_font_size, 0.0);

        assert_eq!(ctx.root_font_size, f32::MIN);

    }

    #[test]

    fn zero_font_size_context_resolves_em_to_zero_without_dividing_by_it() {

        let p = params(LogicalSize::zero(), LogicalSize::zero(), 0.0, 0.0);

        let ctx = p.to_resolution_context();

        assert_eq!(PixelValue::em(10.0).resolve_with_context(&ctx, PropertyContext::Margin), 0.0);

        assert_eq!(PixelValue::rem(10.0).resolve_with_context(&ctx, PropertyContext::Margin), 0.0);

        // A zero-sized viewport must not turn vmin/vmax into NaN.

        let vmin = PixelValue::from_metric(SizeMetric::Vmin, 50.0);

        assert_eq!(vmin.resolve_with_context(&ctx, PropertyContext::Padding), 0.0);

    }

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

    // UnresolvedBoxProps

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

    #[test]

    fn unresolved_box_props_default_resolves_to_an_all_zero_box() {

        let r = UnresolvedBoxProps::default().resolve(&distinct_params());

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

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

        assert!(!r.margin_auto.left && !r.margin_auto.right);

    }

    #[test]

    fn unresolved_box_props_resolve_applies_the_right_property_context_per_edge() {

        let p = distinct_params(); // 800x600 block

        let b = UnresolvedBoxProps {

            vertical_writing_mode: false,

            margin: UnresolvedEdge::new(

                UnresolvedMargin::Auto,

                UnresolvedMargin::Length(PixelValue::percent(10.0)), // -> 80 (width)

                UnresolvedMargin::Zero,

                UnresolvedMargin::Auto,

            ),

            padding: UnresolvedEdge::new(

                PixelValue::percent(10.0), // -> 80 (width, even on the top edge)

                PixelValue::px(4.0),

                PixelValue::px(4.0),

                PixelValue::px(4.0),

            ),

            border: UnresolvedEdge::new(

                PixelValue::percent(10.0), // -> 0 (percent is invalid on border-width)

                PixelValue::px(2.0),

                PixelValue::px(2.0),

                PixelValue::px(2.0),

            ),

        };

        let r = b.resolve(&p);

        assert_eq!(r.margin.top, 0.0, "auto margin resolves to 0 px");

        assert_eq!(r.margin.right, 80.0);

        assert_eq!(r.padding.top, 80.0);

        assert_eq!(r.border.top, 0.0, "percent border-width must collapse to 0");

        assert_eq!(r.border.left, 2.0);

        // The auto flags must survive resolution — they are what drives centering.

        assert!(r.margin_auto.top);

        assert!(r.margin_auto.left);

        assert!(!r.margin_auto.right);

        assert!(!r.margin_auto.bottom);

    }

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

    // ResolvedBoxProps::inner_size

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

    #[test]

    fn inner_size_of_a_zero_box_is_zero() {

        let bp = ResolvedBoxProps::default();

        for wm in ALL_WM {

            let s = bp.inner_size(LogicalSize::zero(), wm);

            assert_eq!(s.width, 0.0);

            assert_eq!(s.height, 0.0);

        }

    }

    #[test]

    fn inner_size_subtracts_border_and_padding_but_not_margin() {

        let bp = props(

            edges(100.0, 100.0, 100.0, 100.0), // margin — must be ignored

            edges(1.0, 2.0, 4.0, 8.0),         // padding

            edges(10.0, 20.0, 30.0, 40.0),     // border

        );

        // width  loses left+right: (8+2) + (40+20) = 70

        // height loses top+bottom: (1+4) + (10+30) = 45

        let s = bp.inner_size(LogicalSize::new(200.0, 100.0), LayoutWritingMode::HorizontalTb);

        assert_eq!(s.width, 130.0);

        assert_eq!(s.height, 55.0);

    }

    #[test]

    fn inner_size_is_identical_in_every_writing_mode() {

        // Physically, content-box = border-box minus the same four edges regardless

        // of writing mode. The main/cross indirection must cancel out exactly; a

        // transposed arm in one mode would show up right here.

        let bp = props(

            EdgeSizes::default(),

            edges(1.0, 2.0, 4.0, 8.0),

            edges(10.0, 20.0, 30.0, 40.0),

        );

        let outer = LogicalSize::new(200.0, 100.0);

        let base = bp.inner_size(outer, LayoutWritingMode::HorizontalTb);

        for wm in ALL_WM {

            let s = bp.inner_size(outer, wm);

            assert_eq!(s.width, base.width, "{wm:?} width diverged");

            assert_eq!(s.height, base.height, "{wm:?} height diverged");

        }

    }

    #[test]

    fn inner_size_floors_at_zero_when_border_and_padding_exceed_the_box() {

        // CSS: if padding+border overflow the border-box, content is 0 — never negative.

        let bp = props(

            EdgeSizes::default(),

            edges(100.0, 100.0, 100.0, 100.0),

            edges(100.0, 100.0, 100.0, 100.0),

        );

        for wm in ALL_WM {

            let s = bp.inner_size(LogicalSize::new(10.0, 10.0), wm);

            assert_eq!(s.width, 0.0, "{wm:?}");

            assert_eq!(s.height, 0.0, "{wm:?}");

            assert!(s.width >= 0.0 && s.height >= 0.0);