//! 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,

    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,

    PositionedItem, 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>,

}

#[derive(Debug, Clone)]

pub struct GlyphRun<T: ParsedFontTrait> {

    /// 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,

    /// The font used for this glyph run.

    pub font: T, // Changed from Arc<T> - T is already cheap to clone (e.g. FontRef)

    /// 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,

}

/// Simple version of get_glyph_runs that doesn't require fonts.

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

            |positioned_glyphs: &[ShapedGlyph],

             item_origin_x: f32,

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

                        // 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.

                        }

        }

/// Same as `get_glyph_positions`, but returns a list of `GlyphRun`s

/// instead of a flat list of glyphs. This groups glyphs by their font and

/// color, which can be more efficient for rendering.

    // Group glyphs by font and color

            |positioned_glyphs: &[ShapedGlyph],

             item_origin_x: f32,

                    // Look up the font from the fonts container

                    };

                    // Calculate absolute position: baseline position + GPOS offset

                    // changes. Text-decoration does not affect shaping (per spec, shaping

                    // must not break when only text-decoration changes), but rendering

                    // runs still split for correct visual output.

                    // Advance the pen for the next glyph in the cluster/block.

                    // TODO: writing-mode support (vertical text) here

                }

            // This is a rare case for tate-chu-yoko (mixed horizontal+vertical text)

            }

        }

    }

/// 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

        // 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).

            } else {

            };

                // 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.

        }

    }

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

// +spec:display-property:e124e9 - Line box height sized to include aligned layout bounds of all inline-level boxes

// LINE BOX METRICS ACCUMULATOR (CSS 2.2 §10.8.1)

// +spec:height-calculation:18825a - half-leading model for line box height calculation

// +spec:inline-formatting-context:ce2b15 - line box height from vertical stack of inline-level boxes

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

/// Accumulates metrics for a single line box during inline layout.

///

// +spec:display-property:61a267 - inline-sizing default (normal): content area height = font metrics (ascent+descent), no layout effect

// +spec:display-property:a15ae9 - line-height determines layout bounds (contribution to line box logical height)

// +spec:display-property:adc520 - inline-level baseline alignment: each glyph/inline-box aligned to parent baseline, then shifted by vertical-align

// +spec:display-property:e2e64f - line box block-axis sizing from inline-level contents via line-height

/// Implements the CSS 2.2 §10.8.1 "half-leading" model:

/// - Each inline item has a content area (ascent + descent from font metrics)

/// - CSS `line-height` distributes "half-leading" equally above and below

/// - The line box height is the maximum extent of all items after leading

///

/// Usage: create a new `LineBoxMetrics`, call `add_item()` for each inline

/// item on the line, then call `line_height()` and `baseline_offset()`.

#[derive(Debug, Clone)]

pub struct LineBoxMetrics {

    /// Maximum distance above the baseline (positive = up).

    max_above_baseline: f32,

    /// Maximum distance below the baseline (positive = down).

    max_below_baseline: f32,

}

impl LineBoxMetrics {

    /// Add an inline item's metrics to this line box.

    ///

    /// - `ascent`: font ascent (positive, distance from baseline to top of text)

    /// - `descent`: font descent (positive, distance from baseline to bottom of text)

    /// - `line_height`: the computed CSS `line-height` for this item

    ///

    // +spec:font-metrics:05193a - half-leading model: L = line-height - AD, split above/below

    /// Half-leading = (line_height - (ascent + descent)) / 2, added above and below.

    // +spec:box-model:533ca2 - line-fit-edge:leading: line box height uses half-leading, not inline box margin/padding/border

    // +spec:box-model:04846b - line-fit-edge:leading mode only uses line-height for layout bounds (non-leading modes not yet implemented)

    // +spec:display-property:a15ae9 - line-height determines inline box layout bounds (contribution to line box height)

    // +spec:font-metrics:5c5f79 - leading value: ascent/descent plus positive half-leading sizes line box

    // +spec:font-metrics:3d59af - leading value uses half-leading; margin/padding/border ignored for line box sizing

    // +spec:line-height:b3be30 - half-leading distributed above/below; line box grows to accommodate overflow

    // +spec:overflow:196059 - half-leading model: L = line-height - AD, half added above A and below D

    /// The total height of the line box.

    /// The offset from the top of the line box to the baseline.

}