//! A helper module to extract final, absolute glyph positions from a layout.

//! This is useful for renderers that work with simple lists of glyphs.

use azul_core::{

    dom::NodeId,

    geom::{LogicalPosition, LogicalSize},

    ui_solver::GlyphInstance,

};

use azul_css::props::basic::ColorU;

use azul_css::props::style::StyleBackgroundContent;

use crate::text3::cache::{

    get_item_vertical_metrics_approx, InlineBorderInfo, LoadedFonts, ParsedFontTrait, Point,

    ShapedGlyph, ShapedItem, UnifiedLayout,

};

/// Represents a single glyph ready for rendering, with an absolute position on the baseline.

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

pub struct PositionedGlyph {

    pub glyph_id: u16,

    /// The absolute position of the glyph's origin on the baseline.

    pub position: Point,

    /// The advance width of the glyph, useful for caret placement.

    pub advance: f32,

}

/// A simple glyph run without font reference - used when fonts aren't available.

/// The font can be looked up later via `font_hash` if needed.

#[derive(Debug, Clone)]

pub struct SimpleGlyphRun {

    /// The glyphs in this run, with their positions relative to the start of the run.

    pub glyphs: Vec<GlyphInstance>,

    /// The color of the text in this glyph run.

    pub color: ColorU,

    /// Background color for this run (rendered behind text)

    pub background_color: Option<ColorU>,

    /// Full background content layers (for gradients, images, etc.)

    pub background_content: Vec<StyleBackgroundContent>,

    /// Border information for inline elements

    pub border: Option<InlineBorderInfo>,

    /// A hash of the font, useful for caching purposes.

    pub font_hash: u64,

    /// The font size in pixels.

    pub font_size_px: f32,

    /// Text decoration (underline, strikethrough, overline)

    pub text_decoration: crate::text3::cache::TextDecoration,

    /// Whether this is an IME composition preview (should be rendered with special styling)

    pub is_ime_preview: bool,

    /// The source DOM node that generated this text run (for hit-testing)

    pub source_node_id: Option<NodeId>,

}

/// #25: the STORED form of a paint run's glyphs — 8 B/glyph instead of the

/// 20 B `GlyphInstance`. Exploits two invariants of the simple-run contract:

/// `size` is never populated (both builders emit `LogicalSize::default()`),

/// and `point.y` is the run baseline for every glyph except detail glyphs

/// with vertical offsets. Anything that deviates goes in `exceptions` as a

/// FULL instance, so expansion is bit-exact BY CONSTRUCTION — there is no

/// lossy path, only a smaller encoding for the invariant-conforming bulk.

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

pub struct CompactGlyphs {

    /// `(glyph index, pen x)` per glyph, in paint order.

    pub xs: Vec<(u32, f32)>,

    /// The y (baseline) shared by every non-exception glyph. Bit pattern

    /// of the first instance's y (float identity — the NaN rule).

    pub y: f32,

    /// The size shared by every non-exception glyph (today always

    /// `LogicalSize::default()` — kept as data, not assumption).

    pub size: LogicalSize,

    /// `(position in xs, full original instance)` for glyphs whose y or

    /// size deviate from the shared values. Sorted by position.

    pub exceptions: Vec<(u32, GlyphInstance)>,

}

impl CompactGlyphs {

    /// Compacts a transient instance list. Exact: `expand()` of the result

    /// reproduces `v` bit for bit (floats compared as bit patterns when

    /// choosing the shared y/size — NaNs become exceptions, never a match).

    #[must_use]

        }

    #[must_use]

    #[must_use]

    /// Reconstructs instance `i` exactly as it was compacted.

    #[must_use]

    #[must_use]

    #[must_use]

    /// Exact expansion, in order.

    /// The paint expansion: every instance translated by `(dx, dy)` — the

    /// same Vec the DL generator built by copy-then-offset before #25.

    #[must_use]

    /// Heap bytes retained by this encoding (memory report).

    #[must_use]

}

/// #25: the STORED paint run — [`SimpleGlyphRun`]'s header with the glyph

/// list compacted. `SimpleGlyphRun` remains the TRANSIENT form the two

/// builders produce and the equivalence gates compare; the store chokepoint

/// (`CachedInlineLayout` construction) converts once, the same shape as the

/// §3.2 dense retirement.

#[derive(Debug, Clone)]

pub struct CompactGlyphRun {

    pub glyphs: CompactGlyphs,

    pub color: ColorU,

    pub background_color: Option<ColorU>,

    pub background_content: Vec<StyleBackgroundContent>,

    pub border: Option<InlineBorderInfo>,

    pub font_hash: u64,

    pub font_size_px: f32,

    pub text_decoration: crate::text3::cache::TextDecoration,

    pub is_ime_preview: bool,

    pub source_node_id: Option<NodeId>,

}

impl From<SimpleGlyphRun> for CompactGlyphRun {

}

impl CompactGlyphRun {

    /// The transient form back — for gates and any reader that wants the

    /// instance list. Exact inverse of the `From` conversion.

    #[must_use]

}

/// Bit-exact run equality for the #25 roundtrip gate. Floats compare as

/// BIT PATTERNS — a NaN that survives the compact/expand roundtrip must

/// count as equal (derived `PartialEq` would call that a divergence and

/// a lossy roundtrip that maps NaN to NaN would pass; both wrong ways).

#[must_use]

/// Groups glyphs into runs without requiring font references.

/// Use this when you only need glyph positions and don't need font references.

#[allow(clippy::float_cmp)] // intentional exact compare: change-detection / identity fast-path / cache-key match

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

    // Baseline the open run sits on. Runs merge across layout items when

    // their style matches, and the style predicate below has no notion of

    // WHERE the glyphs are — so every line of a paragraph merged into one

    // run, hence one `DisplayListItem::Text`, hence one damage rect

    // covering all of them. Breaking on the baseline makes a line the unit

    // of damage, so editing line 3 of a paragraph does not repaint lines

    // 1 and 2.

            |positioned_glyphs: &[ShapedGlyph],

             item_origin_x: f32,

             writing_mode: crate::text3::cache::WritingMode,

             source_node_id: Option<NodeId>,

                        // changes (font, color, border, size). Per spec, text-decoration

                        // changes do not affect shaping (shaping is done upstream in

                        // default.rs), but we still break rendering runs for correct drawing.

                        // Border/margin/padding changes break both shaping and rendering runs.

                }

        }

    }

/// +spec:box-model:6c62d3 - suppress margins/borders/padding at inline box split points

/// CSS 2.2 §9.4.2: When an inline box is split across lines, margins, borders,

/// and padding have no visible effect at the split points.

/// Post-process: for runs from the same `source_node_id` that have borders,

/// mark intermediate fragments so `left_inset()`/`right_inset()` suppress edges.

/// Shared by [`get_glyph_runs_simple`] and its dense twin

/// (`crate::text3::dense::get_glyph_runs_simple_dense`) so the fragment

/// semantics cannot drift between the two walkers.

                        }

        }

/// A glyph run optimized for PDF rendering.

///

/// Groups glyphs by font, color, size, and style, while breaking at line boundaries.

/// This struct is used by the PDF renderer to efficiently render text with proper

/// styling, including inline background colors for `<span>` elements.

///

/// # Z-Order for Inline Backgrounds

///

/// The `background_color` field enables proper z-ordering of inline backgrounds:

/// - PDF renderers should iterate over all runs and render backgrounds FIRST

/// - Then iterate again and render all text SECOND

/// - This ensures backgrounds appear behind text, not on top of it

///

/// The display list (`paint_inline_content`) does NOT emit `push_rect()` for inline

/// backgrounds because that would cause double-rendering and z-order issues.

#[derive(Debug, Clone)]

pub struct PdfGlyphRun<T: ParsedFontTrait> {

    /// The glyphs in this run with their absolute positions

    pub glyphs: Vec<PdfPositionedGlyph>,

    /// The color of the text

    pub color: ColorU,

    /// Background color for inline elements (e.g., `<span style="background: yellow">`)

    ///

    /// This is rendered as a filled rectangle behind the text by the PDF renderer.

    /// The rectangle spans from ascent to descent and covers the full width of the run.

    pub background_color: Option<ColorU>,

    /// The font used for this run

    pub font: T,

    /// Font hash for identification

    pub font_hash: u64,

    /// Font size in pixels

    pub font_size_px: f32,

    /// Text decoration flags

    pub text_decoration: crate::text3::cache::TextDecoration,

    /// The line index this run belongs to (for breaking runs at line boundaries)

    pub line_index: usize,

    /// Text direction for this run

    pub direction: crate::text3::cache::BidiDirection,

    /// Writing mode for this run

    pub writing_mode: crate::text3::cache::WritingMode,

    /// The starting position (baseline) of this run - used for `SetTextMatrix`

    pub baseline_start: Point,

    /// Original cluster text for debugging/CID mapping

    pub cluster_texts: Vec<String>,

}

/// A glyph with its absolute position and cluster text for PDF rendering

#[derive(Debug, Clone)]

pub struct PdfPositionedGlyph {

    /// Glyph ID

    pub glyph_id: u16,

    /// Absolute position on the baseline (Y-down coordinate system)

    pub position: Point,

    /// The advance width of this glyph

    pub advance: f32,

    /// The Unicode character(s) this glyph represents (for PDF `ToUnicode` `CMap`)

    /// This is extracted from the cluster text using the glyph's `cluster_offset`

    pub unicode_codepoint: String,

}

/// Extract glyph runs optimized for PDF rendering.

/// This function:

/// - Groups consecutive glyphs by font, color, size, style, and line

/// - Breaks runs at line boundaries (different `line_index`)

/// - Preserves absolute positioning for each glyph (critical for RTL and complex scripts)

/// - Includes cluster text for proper CID/Unicode mapping

#[allow(clippy::float_cmp)] // intentional exact compare: change-detection / identity fast-path / cache-key match

        // Only process text clusters

        };

        // Calculate the baseline position for this cluster

        // Process each glyph in the cluster

        // For extracting the correct unicode codepoint per glyph, we need to track

        // which portion of the cluster text each glyph represents.

        // The cluster_offset in ShapedGlyph is the byte offset into cluster.text

            // Look up the font from the fonts container

            };

            // Calculate absolute glyph position on baseline

            // Extract the unicode codepoint for this specific glyph

            // For simple 1:1 mappings, each glyph gets one character

            // For complex scripts (ligatures, etc.), we may need to assign

            // the whole cluster text to the first glyph, or split it appropriately

                // Simple case: one glyph represents the entire cluster

            } else {

                // Multiple glyphs in cluster - try to extract the character at cluster_offset

                // cluster_offset is the byte offset into the cluster text

                    // Get the character at this byte offset

                } else {

                    // Fallback: if offset is out of range, use the whole cluster for first glyph

                    // or empty for subsequent glyphs (they share the same codepoint)

                    } else {

                    }

                }

            };

            // Font hash change = font change (shaping must break per spec).

            // Border/background change = margin/border/padding non-zero (shaping must break).

            // Text-decoration change = rendering-only break (shaping unaffected per spec).

                // Finalize the current run and start a new one

            // Advance pen position - DON'T add kerning here because it's already

            // included in the positioned_item.position.x from the layout engine!

            // We only advance by the base advance to track our position within this cluster

        }

    }

    // Push the final run if any

/// Transforms the final layout into a simple list of glyphs and their absolute positions.

///

/// This function iterates through all positioned items in a layout, filtering for text clusters

/// and combined text blocks. It calculates the absolute baseline position for each glyph within

/// these items and returns a flat vector of `PositionedGlyph` structs. This is useful for

/// rendering or for clients that need a lower-level representation of the text layout.

///

/// # Arguments

///

/// - `layout` - A reference to the final `UnifiedLayout` produced by the pipeline.

///

/// # Returns

///

/// A `Vec<PositionedGlyph>` containing all glyphs from the layout with their

/// absolute baseline positions.

        }

    }

/// Adversarial unit tests generated for `layout/src/text3/glyphs.rs`.

///

/// The three public entry points are pure transforms over a `UnifiedLayout`, so the

/// interesting failure modes are all in the pen arithmetic (NaN / ±inf / negative

/// kerning), the run-splitting predicates (which use `==` on `f32`), the UTF-8 slicing

/// in the PDF codepoint extraction, and the inline-box fragment post-pass.

///

/// Fixtures use `units_per_em == 0` metrics on purpose: that makes

/// `get_item_vertical_metrics_approx` skip the glyph, so ascent is exactly `0.0` and the

/// baseline lands exactly on `item.position.y`. Every asserted coordinate is therefore

/// exact rather than approximate.

///

/// Where a function has surprising-but-real behaviour, the test PINS it and says so

/// (see `pdf_cluster_offset_inside_multibyte_char_panics` and

/// `pdf_unknown_font_glyph_does_not_advance_the_pen`, both of which are genuine bugs).

///

/// Note: `Point`'s `PartialEq` is `round_eq` (rounds to `isize`), so all coordinate

/// assertions compare the raw `f32` fields instead of whole `Point`s.

#[cfg(test)]

#[allow(

    clippy::float_cmp,

    clippy::too_many_lines,

    clippy::unreadable_literal,

    clippy::similar_names,

    clippy::cast_precision_loss,

    clippy::cast_possible_truncation

)]

mod autotest_generated {

    use std::sync::Arc;

    use azul_core::geom::LogicalSize;

    use rust_fontconfig::FontId;

    use super::*;

    use crate::text3::{

        cache::{

            BidiDirection, BreakType, ClearType, ContentIndex, Glyph, GlyphKind,

            GraphemeClusterId, InlineBreak, InlineContent, InlineSpace, LayoutError,

            LayoutFontMetrics, OverflowInfo, PositionedItem, Rect, ShallowClone, ShapedCluster,

            StyleProperties, TextDecoration, VerticalMetrics, WritingMode,

        },

        script::{Language, Script},

    };

    const FONT_A: u64 = 0xAAAA_AAAA;

    const FONT_B: u64 = 0xBBBB_BBBB;

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

    // Fixtures

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

    /// `units_per_em == 0` => `get_item_vertical_metrics_approx` returns `(0.0, 0.0)`,

    /// so `baseline_y == item.position.y` and every coordinate below is exact.

    fn zero_metrics() -> LayoutFontMetrics {

        LayoutFontMetrics {

            ascent: 0.0,

            descent: 0.0,

            line_gap: 0.0,

            units_per_em: 0,

            x_height: None,

            cap_height: None,

        }

    }

    fn style() -> Arc<StyleProperties> {

        Arc::new(StyleProperties::default())

    }

    fn styled(f: impl FnOnce(&mut StyleProperties)) -> Arc<StyleProperties> {

        let mut s = StyleProperties::default();

        f(&mut s);

        Arc::new(s)

    }

    fn rgba(r: u8, g: u8, b: u8, a: u8) -> ColorU {

        ColorU { r, g, b, a }

    }

    /// A glyph with the standard degenerate metrics, sitting at font `FONT_A`.

    fn glyph(glyph_id: u16, advance: f32, st: &Arc<StyleProperties>) -> ShapedGlyph {

        ShapedGlyph {

            kind: GlyphKind::Character,

            glyph_id,

            cluster_offset: 0,

            advance,

            kerning: 0.0,

            offset: Point { x: 0.0, y: 0.0 },

            vertical_advance: 0.0,

            vertical_offset: Point { x: 0.0, y: 0.0 },

            script: Script::Latin,

            font_hash: FONT_A,

            font_metrics: zero_metrics(),

        }

    }

    /// Returns the `ShapedCluster` (not the `ShapedItem`) so tests can override

    /// `direction` / `style` / `text` before wrapping it with [`item`].

    fn cluster(text: &str, glyphs: Vec<ShapedGlyph>, st: &Arc<StyleProperties>) -> ShapedCluster {

        ShapedCluster {

            flags: crate::text3::cache::ClusterFlags::classify(text),

            source_text: Arc::from(text), source_byte_len: text.len() as u16,

            source_cluster_id: GraphemeClusterId {

                source_run: 0,

                start_byte_in_run: 0,

            },

            source_content_index: ContentIndex {

                run_index: 0,

                item_index: 0,

            },

            source_node_id: None,

            glyphs: glyphs.into_iter().collect(),

            advance: 0.0,

            direction: BidiDirection::Ltr,

            style: st.clone(),

            marker_position_outside: None,

            is_first_fragment: true,

            is_last_fragment: true,

        }

    }

    fn item(c: ShapedCluster) -> ShapedItem {

        ShapedItem::Cluster(c)

    }

    fn combined(glyphs: Vec<ShapedGlyph>) -> ShapedItem {

        ShapedItem::CombinedBlock {

            style: Arc::new(StyleProperties::default()),

            source: ContentIndex {

                run_index: 0,

                item_index: 0,

            },

            glyphs: glyphs.into_iter().collect(),

            // height 0 keeps the fallback ascent (`0.8 * height`) at exactly 0.

            bounds: Rect {

                x: 0.0,

                y: 0.0,

                width: 0.0,

                height: 0.0,

            },

            baseline_offset: 0.0,

        }

    }

    fn tab() -> ShapedItem {

        ShapedItem::Tab {

            source: ContentIndex {

                run_index: 0,

                item_index: 0,

            },

            bounds: Rect {

                x: 0.0,

                y: 0.0,

                width: 8.0,

                height: 0.0,

            },

        }

    }

    fn hard_break() -> ShapedItem {

        ShapedItem::Break {

            source: ContentIndex {

                run_index: 0,

                item_index: 0,

            },

            break_info: InlineBreak {

                break_type: BreakType::Hard,

                clear: ClearType::None,

                content_index: 0,

            },

        }

    }

    fn object() -> ShapedItem {

        ShapedItem::Object {

            source: ContentIndex {

                run_index: 0,

                item_index: 0,

            },

            bounds: Rect {

                x: 0.0,

                y: 0.0,

                width: 10.0,

                height: 10.0,

            },

            baseline_offset: 0.0,

            content: InlineContent::Space(InlineSpace {

                width: 10.0,

                is_breaking: false,

                is_stretchy: false,

            }),

        }

    }

    fn at(i: ShapedItem, x: f32, y: f32, line_index: usize) -> PositionedItem {

        PositionedItem {

            item: i,

            position: Point { x, y },

            line_index,

        }

    }

    fn layout(items: Vec<PositionedItem>) -> UnifiedLayout {

        UnifiedLayout {

            items,

            overflow: OverflowInfo::default(),

        }

    }

    fn border() -> InlineBorderInfo {

        InlineBorderInfo {

            left: 2.0,

            right: 2.0,

            ..InlineBorderInfo::default()

        }

    }

    /// A minimal in-memory `ParsedFontTrait` so `LoadedFonts` can be populated

    /// without touching the filesystem or fontconfig.

    #[derive(Debug, Clone)]

    struct TestFont {

        hash: u64,

    }

    impl ShallowClone for TestFont {

        fn shallow_clone(&self) -> Self {

            self.clone()

        }

    }

    impl ParsedFontTrait for TestFont {

        fn shape_text(

            &self,

            _text: &str,

            _script: Script,

            _language: Language,

            _direction: BidiDirection,

            _style: &StyleProperties,

        ) -> Result<Vec<Glyph>, LayoutError> {

            Ok(Vec::new())

        }

        fn get_hash(&self) -> u64 {

            self.hash

        }

        fn get_glyph_size(&self, _glyph_id: u16, font_size: f32) -> Option<LogicalSize> {

            Some(LogicalSize {

                width: font_size,

                height: font_size,

            })

        }

        fn get_hyphen_glyph_and_advance(&self, font_size: f32) -> Option<(u16, f32)> {

            Some((1, font_size * 0.3))

        }

        fn get_kashida_glyph_and_advance(&self, font_size: f32) -> Option<(u16, f32)> {

            Some((2, font_size * 0.2))

        }

        fn has_glyph(&self, _codepoint: u32) -> bool {

            true

        }

        fn get_vertical_metrics(&self, _glyph_id: u16) -> Option<VerticalMetrics> {

            None

        }

        fn get_font_metrics(&self) -> LayoutFontMetrics {

            zero_metrics()

        }

        fn num_glyphs(&self) -> u16 {

            10

        }

        fn get_space_width(&self) -> Option<usize> {

            Some(500)

        }

    }

    fn fonts_with(hashes: &[u64]) -> LoadedFonts<TestFont> {

        let mut fonts = LoadedFonts::new();

        for &h in hashes {

            fonts.insert(FontId::new(), TestFont { hash: h });

        }

        fonts

    }

    fn no_fonts() -> LoadedFonts<TestFont> {

        LoadedFonts::new()

    }

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

    // get_glyph_positions

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

    #[test]

    fn positions_empty_layout_yields_no_glyphs() {

        assert!(get_glyph_positions(&layout(Vec::new())).is_empty());

    }

    #[test]

    fn positions_ignore_non_text_items() {

        // Object / Tab / Break carry no glyphs and must be skipped, not panicked on.

        let l = layout(vec![

            at(object(), 0.0, 0.0, 0),

            at(tab(), 10.0, 0.0, 0),

            at(hard_break(), 20.0, 0.0, 0),

        ]);

        assert!(get_glyph_positions(&l).is_empty());

    }

    #[test]

    fn positions_cluster_without_glyphs_yields_nothing() {

        let st = style();

        let l = layout(vec![at(item(cluster("abc", Vec::new(), &st)), 0.0, 0.0, 0)]);

        assert!(get_glyph_positions(&l).is_empty());

    }

    #[test]

    fn positions_pen_advances_by_advance_plus_kerning() {

        let st = style();

        let mut g0 = glyph(1, 10.0, &st);

        g0.kerning = 2.0;

        let mut g1 = glyph(2, 10.0, &st);

        g1.kerning = 2.0;

        let g2 = glyph(3, 10.0, &st);

        let l = layout(vec![at(

            item(cluster("abc", vec![g0, g1, g2], &st)),

            100.0,

            50.0,

            0,

        )]);

        let out = get_glyph_positions(&l);

        assert_eq!(out.len(), 3);

        assert_eq!(out[0].position.x, 100.0);

        assert_eq!(out[1].position.x, 112.0, "advance 10 + kerning 2");

        assert_eq!(out[2].position.x, 124.0);

        // upem == 0 => ascent == 0 => baseline == item.position.y, exactly.

        for g in &out {

            assert_eq!(g.position.y, 50.0);

        }

    }

    #[test]

    fn positions_negative_kerning_walks_the_pen_backwards() {

        // Kerning is unbounded below; a tighter-than-advance kern makes x decrease.

        let st = style();

        let mut g = glyph(1, 10.0, &st);

        g.kerning = -12.0;

        let l = layout(vec![at(

            item(cluster("aaa", vec![g.clone(), g.clone(), g], &st)),

            0.0,

            0.0,

            0,

        )]);

        let out = get_glyph_positions(&l);

        assert_eq!(out[0].position.x, 0.0);

        assert_eq!(out[1].position.x, -2.0);

        assert_eq!(out[2].position.x, -4.0);

    }

    #[test]

    fn positions_gpos_y_offset_is_subtracted_in_y_down_space() {

        let st = style();

        let mut g = glyph(1, 10.0, &st);

        g.offset = Point { x: 3.0, y: 7.0 };

        let l = layout(vec![at(item(cluster("a", vec![g], &st)), 0.0, 100.0, 0)]);

        let out = get_glyph_positions(&l);

        assert_eq!(out[0].position.x, 3.0, "x offset is added");

        assert_eq!(

            out[0].position.y, 93.0,

            "positive GPOS y (up) subtracts in Y-down space"

        );

    }

    #[test]

    fn positions_combined_block_glyphs_do_not_stack_at_one_x() {

        // Regression: CombinedBlock carries raw advances, so the pen must accumulate

        // across the whole slice instead of resetting per glyph.

        let st = style();

        let l = layout(vec![at(

            combined(vec![glyph(1, 10.0, &st), glyph(2, 10.0, &st)]),

            100.0,

            0.0,

            0,

        )]);

        let out = get_glyph_positions(&l);

        assert_eq!(out.len(), 2);

        assert_eq!(out[0].position.x, 100.0);

        assert_eq!(out[1].position.x, 110.0);

    }

    #[test]

    fn positions_round_trip_glyph_id_and_advance_verbatim() {

        let st = style();

        let mut g = glyph(u16::MAX, f32::MIN_POSITIVE, &st);

        g.advance = f32::MIN_POSITIVE;

        let l = layout(vec![at(item(cluster("\u{10FFFF}", vec![g], &st)), 0.0, 0.0, 0)]);

        let out = get_glyph_positions(&l);

        assert_eq!(out[0].glyph_id, u16::MAX, "glyph id is copied, not truncated");

        assert_eq!(out[0].advance, f32::MIN_POSITIVE, "advance is copied verbatim");

    }

    #[test]

    fn positions_nan_advance_poisons_later_glyphs_but_does_not_panic() {

        let st = style();

        let l = layout(vec![at(

            item(cluster(

                "ab",

                vec![glyph(1, f32::NAN, &st), glyph(2, 10.0, &st)],

                &st,

            )),

            0.0,

            0.0,

            0,

        )]);

        let out = get_glyph_positions(&l);

        assert_eq!(out.len(), 2);

        assert_eq!(out[0].position.x, 0.0, "first glyph is placed before the NaN advance");

        assert!(

            out[1].position.x.is_nan(),

            "NaN advance propagates into the pen — pinned, not fixed"

        );

    }

    #[test]

    fn positions_huge_advances_saturate_to_infinity_without_panicking() {

        let st = style();

        let l = layout(vec![at(

            item(cluster(

                "abc",

                vec![

                    glyph(1, f32::MAX, &st),

                    glyph(2, f32::MAX, &st),

                    glyph(3, 1.0, &st),

                ],

                &st,

            )),

            0.0,

            0.0,

            0,

        )]);

        let out = get_glyph_positions(&l);

        assert_eq!(out[0].position.x, 0.0);

        assert_eq!(out[1].position.x, f32::MAX);

        assert!(

            out[2].position.x.is_infinite() && out[2].position.x.is_sign_positive(),

            "f32 saturates on overflow instead of wrapping/panicking"

        );

    }

    #[test]

    fn positions_ten_thousand_glyphs_do_not_overflow() {

        let st = style();

        let glyphs: Vec<ShapedGlyph> = (0..10_000u32)

            .map(|i| glyph((i % 65536) as u16, 1.0, &st))

            .collect();

        let l = layout(vec![at(item(cluster("x", glyphs, &st)), 0.0, 0.0, 0)]);

        let out = get_glyph_positions(&l);

        assert_eq!(out.len(), 10_000);

        assert_eq!(out[9_999].position.x, 9_999.0, "integral f32 accumulation is exact here");

    }

    #[test]

    fn positions_pen_resets_at_each_item_origin() {

        let st = style();

        let l = layout(vec![

            at(item(cluster("a", vec![glyph(1, 10.0, &st)], &st)), 0.0, 0.0, 0),

            at(item(cluster("b", vec![glyph(2, 10.0, &st)], &st)), 200.0, 30.0, 1),

        ]);

        let out = get_glyph_positions(&l);

        assert_eq!(out[1].position.x, 200.0, "pen restarts from the item origin");

        assert_eq!(out[1].position.y, 30.0);

    }

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

    // get_glyph_runs_simple

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

    #[test]

    fn simple_empty_layout_yields_no_runs() {

        assert!(get_glyph_runs_simple(&layout(Vec::new())).is_empty());

    }

    #[test]

    fn simple_non_text_items_yield_no_runs() {

        let l = layout(vec![

            at(object(), 0.0, 0.0, 0),

            at(tab(), 0.0, 0.0, 0),

            at(hard_break(), 0.0, 0.0, 0),

        ]);

        assert!(get_glyph_runs_simple(&l).is_empty());

    }

    #[test]

    fn simple_uniform_glyphs_merge_into_one_run_across_items() {

        // The current run is NOT flushed at item boundaries — only on a style change.

        let st = style();

        let l = layout(vec![

            at(

                item(cluster("ab", vec![glyph(1, 10.0, &st), glyph(2, 10.0, &st)], &st)),

                0.0,

                0.0,

                0,

            ),

            at(

                item(cluster("cd", vec![glyph(3, 10.0, &st), glyph(4, 10.0, &st)], &st)),

                50.0,

                0.0,

                1,

            ),

        ]);

        let runs = get_glyph_runs_simple(&l);

        assert_eq!(runs.len(), 1, "identical style => one run, even across lines");

        assert_eq!(runs[0].glyphs.len(), 4);

        assert_eq!(runs[0].glyphs[2].point.x, 50.0, "pen still restarts per item");

    }

    #[test]

    fn simple_color_change_splits_the_run() {

        let a = styled(|s| s.color = rgba(255, 0, 0, 255));

        let b = styled(|s| s.color = rgba(0, 0, 255, 255));

        let l = layout(vec![

        // (2026-08-10, per-glyph style removed: a style change can only

        // occur at a CLUSTER boundary — the pipeline splits runs by style

        // BEFORE shaping — so this fixture uses one cluster per style,

        // the only shape the engine can actually produce.)

            at(item(cluster("a", vec![glyph(1, 10.0, &a)], &a)), 0.0, 0.0, 0),

            at(item(cluster("b", vec![glyph(2, 10.0, &b)], &b)), 10.0, 0.0, 0),

        ]);

        let runs = get_glyph_runs_simple(&l);

        assert_eq!(runs.len(), 2);

        assert_eq!(runs[0].color, rgba(255, 0, 0, 255));

        assert_eq!(runs[1].color, rgba(0, 0, 255, 255));

    }

    #[test]

    fn simple_font_hash_change_splits_the_run() {

        let st = style();

        let mut g1 = glyph(2, 10.0, &st);

        g1.font_hash = FONT_B;

        let l = layout(vec![at(

            item(cluster("ab", vec![glyph(1, 10.0, &st), g1], &st)),

            0.0,

            0.0,

            0,

        )]);

        let runs = get_glyph_runs_simple(&l);

        assert_eq!(runs.len(), 2);

        assert_eq!(runs[0].font_hash, FONT_A);

        assert_eq!(runs[1].font_hash, FONT_B);

    }

    #[test]

    fn simple_font_size_and_decoration_changes_split_the_run() {

        let a = style();

        let b = styled(|s| s.font_size_px = 24.0);

        let c = styled(|s| {

            s.font_size_px = 24.0;

            s.text_decoration = TextDecoration {

                underline: true,

                strikethrough: false,

                overline: false,

            };

        });

        let l = layout(vec![

        // (2026-08-10, per-glyph style removed: a style change can only

        // occur at a CLUSTER boundary — the pipeline splits runs by style

        // BEFORE shaping — so this fixture uses one cluster per style,

        // the only shape the engine can actually produce.)

            at(item(cluster("a", vec![glyph(1, 10.0, &a)], &a)), 0.0, 0.0, 0),

            at(item(cluster("b", vec![glyph(2, 10.0, &b)], &b)), 10.0, 0.0, 0),

            at(item(cluster("c", vec![glyph(3, 10.0, &c)], &c)), 20.0, 0.0, 0),

        ]);

        let runs = get_glyph_runs_simple(&l);

        assert_eq!(runs.len(), 3, "size change and decoration change both break");

        assert_eq!(runs[0].font_size_px, 16.0);

        assert_eq!(runs[1].font_size_px, 24.0);

        assert!(runs[2].text_decoration.underline);

    }

    #[test]

    fn simple_background_content_change_splits_the_run() {

        let a = style();

        let b = styled(|s| {

            s.background_content = vec![StyleBackgroundContent::Color(rgba(1, 2, 3, 4))];

        });

        let l = layout(vec![

        // (2026-08-10, per-glyph style removed: a style change can only

        // occur at a CLUSTER boundary — the pipeline splits runs by style

        // BEFORE shaping — so this fixture uses one cluster per style,

        // the only shape the engine can actually produce.)

            at(item(cluster("a", vec![glyph(1, 10.0, &a)], &a)), 0.0, 0.0, 0),

            at(item(cluster("b", vec![glyph(2, 10.0, &b)], &b)), 10.0, 0.0, 0),

        ]);

        let runs = get_glyph_runs_simple(&l);

        assert_eq!(runs.len(), 2);

        assert!(runs[0].background_content.is_empty());

        assert_eq!(runs[1].background_content.len(), 1);

    }

    #[test]

    fn simple_source_node_id_change_splits_the_run() {

        let st = style();

        let mut c0 = cluster("a", vec![glyph(1, 10.0, &st)], &st);

        c0.source_node_id = Some(NodeId::new(3));

        let mut c1 = cluster("b", vec![glyph(2, 10.0, &st)], &st);

        c1.source_node_id = Some(NodeId::new(4));

        let l = layout(vec![

            at(item(c0), 0.0, 0.0, 0),

            at(item(c1), 10.0, 0.0, 0),

        ]);

        let runs = get_glyph_runs_simple(&l);

        assert_eq!(runs.len(), 2, "hit-testing identity must not be merged away");

        assert_eq!(runs[0].source_node_id, Some(NodeId::new(3)));

        assert_eq!(runs[1].source_node_id, Some(NodeId::new(4)));

    }

    #[test]

    fn simple_nan_font_size_forces_one_run_per_glyph() {

        // The run predicate compares font sizes with `==`. NaN != NaN, so a NaN

        // font-size defeats run coalescing entirely: N glyphs => N runs.

        let nan = styled(|s| s.font_size_px = f32::NAN);

        let l = layout(vec![at(

            item(cluster(

                "abc",

                vec![

                    glyph(1, 10.0, &nan),

                    glyph(2, 10.0, &nan),

                    glyph(3, 10.0, &nan),

                ],

                &nan,

            )),

            0.0,

            0.0,