//! Core types and layout pipeline for the text/inline formatting context.

//!

//! This module defines the central data structures (`UnifiedConstraints`,

//! `LayoutCache`, `FontManager`, `UnifiedLayout`, etc.) and implements the

//! 5-stage inline layout pipeline:

//!

//! 1. **Logical Analysis** — `InlineContent` → `LogicalItem`

//! 2. **BiDi Reordering** — `LogicalItem` → `VisualItem`

//! 3. **Shaping** — `VisualItem` → `ShapedItem`

//! 4. **Text Orientation** — vertical writing-mode transforms

//! 5. **Flow / Positioning** — line breaking + final `PositionedItem` placement

//!

//! The module also contains cursor movement helpers, caching infrastructure

//! (per-item and monolithic), and font management (`FontContext`, `FontManager`,

//! `LoadedFonts`).  Integration with the box layout solver lives in

//! `solver3/fc.rs`.

use std::{

    cmp::Ordering,

    collections::{

        hash_map::{DefaultHasher, HashMap},

        BTreeSet, HashSet,

    },

    hash::{Hash, Hasher},

    mem::discriminant,

    num::NonZeroUsize,

    sync::{Arc, Mutex},

};

pub use azul_core::selection::{ContentIndex, GraphemeClusterId};

use azul_core::{

    dom::NodeId,

    geom::{LogicalPosition, LogicalRect, LogicalSize},

    resources::ImageRef,

    selection::{CursorAffinity, SelectionRange, TextCursor},

    ui_solver::GlyphInstance,

};

use azul_css::{

    corety::LayoutDebugMessage, props::basic::ColorU, props::style::StyleBackgroundContent,

};

#[cfg(feature = "text_layout_hyphenation")]

use hyphenation::{Hyphenator, Language as HyphenationLanguage, Load, Standard};

use rust_fontconfig::{FcFontCache, FcPattern, FcWeight, FontId, PatternMatch, UnicodeRange};

use smallvec::{smallvec, SmallVec};

use unicode_bidi::{BidiInfo, Level, TextSource};

use unicode_segmentation::UnicodeSegmentation;

/// Glyph storage for a single shaped cluster. Inline one glyph (the

/// common case for Latin text), spill to heap for ligatures / combining

/// marks / multi-glyph clusters. The `union` feature of smallvec packs

/// the inline buffer and the heap pointer into the same bytes, so sizeof

/// stays `sizeof(ShapedGlyph) + 2*usize` regardless of inline/heap state.

pub type ShapedGlyphVec = SmallVec<[ShapedGlyph; 1]>;

/// CSS `line-height` value.

///

/// `Normal` defers resolution to the point where font metrics are available,

/// computing `(ascent + |descent| + lineGap) / upem * fontSize`.

/// `Px` is an already-resolved pixel value from an explicit CSS declaration

/// (e.g. `line-height: 1.5` → `Px(fontSize * 1.5)`).

#[derive(Debug, Clone, Copy)]

pub enum LineHeight {

    /// `line-height: normal` — resolve from font metrics at layout time

    Normal,

    /// Pre-resolved pixel value (from CSS `line-height: <number|length|percentage>`)

    Px(f32),

}

impl Default for LineHeight {

}

impl LineHeight {

    /// Resolve to a pixel value, using font metrics when `Normal`.

    ///

    /// `ascent`, `descent` (negative in OpenType convention), `line_gap` are in font units.

    /// `font_size_px` and `units_per_em` are used to scale.

            LineHeight::Normal => {

            }

        }

    /// Resolve using a `LayoutFontMetrics` struct for convenience.

}

impl PartialEq for LineHeight {

        }

}

impl Eq for LineHeight {}

impl Hash for LineHeight {

}

// Stub type when hyphenation is disabled

#[cfg(not(feature = "text_layout_hyphenation"))]

pub struct Standard;

#[cfg(not(feature = "text_layout_hyphenation"))]

impl Standard {

    /// Stub hyphenate method that returns no breaks

    pub fn hyphenate<'a>(&'a self, _word: &'a str) -> StubHyphenationBreaks {

        StubHyphenationBreaks { breaks: Vec::new() }

    }

}

/// Result of hyphenation (stub when feature is disabled)

#[cfg(not(feature = "text_layout_hyphenation"))]

pub struct StubHyphenationBreaks {

    pub breaks: Vec<usize>,

}

// Always import Language from script module

use crate::text3::script::{script_to_language, Language, Script};

/// Available space for layout, similar to Taffy's AvailableSpace.

///

/// This type explicitly represents the three possible states for available space:

///

/// - `Definite(f32)`: A specific pixel width is available

/// - `MinContent`: Layout should use minimum content width (shrink-wrap)

/// - `MaxContent`: Layout should use maximum content width (no line breaks unless necessary)

///

/// This is critical for proper handling of intrinsic sizing in Flexbox/Grid

/// where the available space may be indefinite during the measure phase.

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

pub enum AvailableSpace {

    /// A specific amount of space is available (in pixels).

    /// Must be >= 0.  A value of 0.0 means "genuinely zero-width container"

    /// (e.g. `width: 0px`), NOT "unresolved".

    Definite(f32),

    /// The node should be laid out under a min-content constraint

    MinContent,

    /// The node should be laid out under a max-content constraint.

    /// This is the correct default: "lay out to natural width, no constraint".

    MaxContent,

}

impl Default for AvailableSpace {

    /// Default is `MaxContent` — the absence of a width constraint.

    /// Never `Definite(0.0)`, which would make every word overflow.

}

impl AvailableSpace {

    /// Returns true if this is a definite (finite, known) amount of space

    /// Returns true if this is an indefinite (min-content or max-content) constraint

    /// Returns the definite value if available, or a fallback for indefinite constraints

        }

    /// Returns the definite value, or a large value for both min-content and max-content.

    /// 

    /// For intrinsic sizing, we use a large value to let text lay out fully,

    /// then measure the result. The distinction between min/max-content is handled

    /// by the line breaking algorithm, not by constraining the available width.

        }

    /// Create from an f32 value, recognizing special sentinel values.

    ///

    /// This function provides backwards compatibility with code that uses f32 for constraints:

    /// - `f32::INFINITY` or `f32::MAX` → `MaxContent` (no line wrapping)

    /// - `0.0` → `MinContent` (maximum line wrapping, return longest word width)

    /// - Other values → `Definite(value)`

    ///

    /// Note: Using sentinel values like 0.0 for MinContent is fragile. Prefer using

    /// `AvailableSpace::MinContent` directly when possible.

            // Treat very large values (including f32::MAX) as MaxContent

            // Treat zero or negative as MinContent (shrink-wrap)

        } else {

        }

}

impl Hash for AvailableSpace {

}

// Re-export traits for backwards compatibility

pub use crate::font_traits::{ParsedFontTrait, ShallowClone};

// --- Core Data Structures for the New Architecture ---

/// Key for caching font chains - based only on CSS properties, not text content

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

pub struct FontChainKey {

    pub font_families: Vec<String>,

    pub weight: FcWeight,

    pub italic: bool,

    pub oblique: bool,

}

/// Either a FontChainKey (resolved via fontconfig) or a direct FontRef hash.

/// 

/// This enum cleanly separates:

/// - `Chain`: Fonts resolved through fontconfig with fallback support

/// - `Ref`: Direct FontRef that bypasses fontconfig entirely (e.g., embedded icon fonts)

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

pub enum FontChainKeyOrRef {

    /// Regular font chain resolved via fontconfig

    Chain(FontChainKey),

    /// Direct FontRef identified by pointer address (covers entire Unicode range, no fallbacks)

    Ref(usize),

}

impl FontChainKeyOrRef {

    /// Create from a FontStack enum

        }

    /// Returns true if this is a direct FontRef

    /// Returns the FontRef pointer if this is a Ref variant

        }

    /// Returns the FontChainKey if this is a Chain variant

        }

}

impl FontChainKey {

    /// Create a FontChainKey from a slice of font selectors

        } else {

        };

}

/// A map of pre-loaded fonts, keyed by FontId (from rust-fontconfig)

///

/// This is passed to the shaper - no font loading happens during shaping

/// The fonts are loaded BEFORE layout based on the font chains and text content.

///

/// Provides both FontId and hash-based lookup for efficient glyph operations.

#[derive(Debug, Clone)]

pub struct LoadedFonts<T> {

    /// Primary storage: FontId -> Font

    pub fonts: HashMap<FontId, T>,

    /// Reverse index: font_hash -> FontId for fast hash-based lookups

    hash_to_id: HashMap<u64, FontId>,

}

impl<T: ParsedFontTrait> LoadedFonts<T> {

    /// Insert a font with its FontId

    /// Get a font by FontId

    /// Get a font by its hash

    /// Get the FontId for a hash

    /// Check if a FontId is present

    /// Check if a hash is present

    /// Iterate over all fonts

    /// Get the number of loaded fonts

    /// Check if empty

}

impl<T: ParsedFontTrait> Default for LoadedFonts<T> {

}

impl<T: ParsedFontTrait> FromIterator<(FontId, T)> for LoadedFonts<T> {

}

/// Enum that wraps either a fontconfig-resolved font (T) or a direct FontRef.

///

/// This allows the shaping code to handle both fontconfig-resolved fonts

/// and embedded fonts (FontRef) uniformly through the ParsedFontTrait interface.

#[derive(Debug, Clone)]

pub enum FontOrRef<T> {

    /// A font loaded via fontconfig

    Font(T),

    /// A direct FontRef (embedded font, bypasses fontconfig)

    Ref(azul_css::props::basic::FontRef),

}

impl<T: ParsedFontTrait> ShallowClone for FontOrRef<T> {

        }

}

impl<T: ParsedFontTrait> ParsedFontTrait for FontOrRef<T> {

        }

        }

        }

        }

        }

        }

        }

        }

        }

        }

}

/// Bundles all font-related state that can be shared across layout passes.

///

/// Separates font concerns from layout/rendering state (`LayoutWindow`).

/// Each test/render creates a fresh `LayoutWindow` from a shared `FontContext`,

/// avoiding stale layout cache reuse while keeping parsed fonts warm.

///

/// Usage:

/// ```ignore

/// let ctx = FontContext::from_fc_cache(fc_cache);

/// ctx.pre_resolve_chains(&styled_dom, &platform);

/// ctx.load_fonts_for_chains();

///

/// // Per-test: create fresh LayoutWindow from context

/// let mut window = LayoutWindow::from_font_context(&ctx)?;

/// window.layout_and_generate_display_list(styled_dom, ...)?;

/// ```

#[derive(Debug, Clone)]

pub struct FontContext {

    /// The shared font cache. As of rust-fontconfig 4.1 this type is

    /// itself backed by `Arc<RwLock<_>>`, so cloning is cheap and all

    /// clones see builder-thread writes immediately — no more `Arc<T>`

    /// wrapping is needed and no more stale-snapshot refresh dance.

    pub fc_cache: FcFontCache,

    pub parsed_fonts: Arc<Mutex<HashMap<FontId, azul_css::props::basic::FontRef>>>,

    pub font_chain_cache: HashMap<FontChainKey, rust_fontconfig::FontFallbackChain>,

    pub embedded_fonts: HashMap<u64, azul_css::props::basic::FontRef>,

    /// Reverse map: font_family_hash → actual StyleFontFamilyVec.

    /// Accumulated across DOMs for persistence. Copied to FontManager on LayoutWindow creation.

    pub font_hash_to_families: HashMap<u64, azul_css::props::basic::font::StyleFontFamilyVec>,

    /// Optional link back to the live `FcFontRegistry`. Present iff the

    /// caller wants the scout-on-demand path

    /// ([`rust_fontconfig::registry::FcFontRegistry::request_and_resolve_with_scripts`]),

    /// which priority-bumps the builder for not-yet-parsed families

    /// rather than falling back to the empty-snapshot response.

    pub registry: Option<Arc<rust_fontconfig::registry::FcFontRegistry>>,

}

impl FontContext {

    /// Create from an `FcFontCache`. Parsed fonts, font chains, and

    /// embedded fonts start empty.

    ///

    /// The resulting `FontContext` has `registry = None`, so font

    /// chain resolution only sees what's already in the cache. For

    /// the scout-on-demand path, use [`FontContext::from_registry`]

    /// instead, which keeps a handle to the registry so that chain

    /// resolution can lazy-parse families the DOM needs.

    /// Create from a live `FcFontRegistry`. The `fc_cache` field gets

    /// a *shared* handle to the registry's cache (cheap `Arc::clone`

    /// on the v4.1 shared-state cache) — writes by builder threads

    /// show up immediately in every reader. Chain resolution goes

    /// through

    /// [`rust_fontconfig::registry::FcFontRegistry::request_and_resolve_with_scripts`]

    /// which priority-bumps the builder for unparsed families and

    /// waits for them. This is the "scout-on-demand" path: a

    /// headless renderer can skip the eager common-stack parse and

    /// pay only the per-family cost on first use, dropping peak RSS

    /// by the common-stack metadata size (~15 MiB on macOS).

    /// Pre-resolve font chains for a StyledDom's CSS font stacks.

    /// Call this before layout so text rendering doesn't skip glyphs.

    ///

    /// Unicode-fallback fonts are limited to the scripts actually

    /// present in the document's text content — for an ASCII-only

    /// page, this skips the ~300 MiB Arial-Unicode / CJK / Arabic

    /// pull-in entirely. See

    /// [`crate::solver3::getters::scripts_present_in_styled_dom`].

        use crate::solver3::getters::{

            collect_font_stacks_from_styled_dom, collect_used_codepoints,

            prune_chain_to_used_chars, resolve_font_chains, scripts_present_in_styled_dom,

        };

        // Coverage-based prune (matches `collect_and_resolve_font_chains_with_registration`).

    /// Load parsed font bytes from disk for all fonts referenced in `font_chain_cache`.

    ///

    /// Thin wrapper that materialises a `ResolvedFontChains` from the

    /// cached chain map and delegates the actual disk-load to the

    /// shared `FontManager::load_missing_for_chains` helper, so the

    /// "collect → diff → load → insert" sequence lives in exactly

    /// one place. Failures are silently dropped here (the caller is

    /// the warmup path which has no good place to log them); use

    /// `FontManager::load_missing_for_chains` directly for diagnostics.

        use crate::solver3::getters::ResolvedFontChains;

        use crate::text3::default::PathLoader;

        // Borrow our shared `parsed_fonts` Arc as a transient

        // FontManager so we can use the helper. `from_arc_shared`

        // returns a manager that mutates the same underlying pool.

        };

    /// Convert into a `FontManager` with all data populated.

    /// Carries the `registry` forward so the resulting manager also

    /// has the scout-on-demand path available.

}

#[derive(Debug)]

pub struct FontManager<T> {

    /// The font-path cache. `FcFontCache` in rust-fontconfig 4.1 is

    /// already a shared handle internally (`Arc<RwLock<_>>`), so no

    /// further `Arc<...>` wrapping is needed — clones are cheap and

    /// all clones see builder writes instantly.

    pub fc_cache: FcFontCache,

    /// Holds the actual parsed font (usually with the font bytes attached).

    /// Wrapped in Arc so multiple FontManager instances can share the same

    /// pool of already-parsed fonts (avoids re-reading from disk).

    pub parsed_fonts: Arc<Mutex<HashMap<FontId, T>>>,

    // Cache for font chains - populated by resolve_all_font_chains() before layout

    // This is read-only during layout - no locking needed for reads

    pub font_chain_cache: HashMap<FontChainKey, rust_fontconfig::FontFallbackChain>,

    /// Cache for direct FontRefs (embedded fonts like Material Icons)

    /// These are fonts referenced via FontStack::Ref that bypass fontconfig

    pub embedded_fonts: Mutex<HashMap<u64, azul_css::props::basic::FontRef>>,

    /// Reverse map: font_family_hash → actual StyleFontFamilyVec.

    /// Accumulated across DOMs. Used by font collection and text shaping to

    /// resolve compact cache hashes without get_property_slow.

    pub font_hash_to_families: HashMap<u64, azul_css::props::basic::font::StyleFontFamilyVec>,

    /// Optional link back to the live `FcFontRegistry`. When present,

    /// chain resolution uses

    /// [`rust_fontconfig::registry::FcFontRegistry::request_and_resolve_with_scripts`]

    /// which lazy-parses system fonts as the DOM requests them

    /// (scout-on-demand). `None` falls back to querying whatever is

    /// already in the shared cache.

    pub registry: Option<Arc<rust_fontconfig::registry::FcFontRegistry>>,

    /// FxHash of the `prev_font_hashes` slice at the moment the last

    /// successful `collect_and_resolve_font_chains_with_registration`

    /// call populated `font_chain_cache`. Lets repeated layouts of the

    /// same DOM skip the ~1.5 ms (cold) / ~0.9 ms (warm) chain resolver

    /// when the set of font-family hashes has not changed. Cleared

    /// whenever `font_chain_cache` is explicitly emptied.

    pub last_resolved_font_stacks_sig: Option<u64>,

}

impl<T: ParsedFontTrait> FontManager<T> {

    /// Create a FontManager sharing the font-path cache handle.

    ///

    /// The parsed_fonts pool starts empty. Fonts loaded during the first

    /// layout pass are cached and will be available on subsequent calls

    /// if you clone the `parsed_fonts` Arc before creating the next instance.

    /// For full sharing, prefer `from_arc_shared()`.

    /// Create a FontManager sharing both the font-path cache and the

    /// already-parsed font data with another FontManager.

    ///

    /// This avoids re-reading and re-parsing font files from disk when

    /// rendering multiple documents that use the same fonts.

    /// Attach a `FcFontRegistry` to this FontManager so subsequent

    /// chain-resolution calls use the on-demand path

    /// ([`rust_fontconfig::registry::FcFontRegistry::request_and_resolve_with_scripts`]).

    /// Get a shareable handle to the parsed-font pool.

    ///

    /// Pass this to `from_arc_shared()` to create a new FontManager that

    /// reuses already-parsed fonts.

    /// Set the font chain cache from externally resolved chains

    ///

    /// This should be called with the result of `resolve_font_chains()` or

    /// `collect_and_resolve_font_chains()` from `solver3::getters`.

    /// Set the font chain cache and record the input signature so

    /// subsequent layouts with the same `prev_font_hashes` skip the

    /// resolver. Pass `sig = None` if the caller cannot compute a

    /// reliable signature — equivalent to the single-arg

    /// `set_font_chain_cache`.

    /// Merge additional font chains into the existing cache

    ///

    /// Useful when processing multiple DOMs that may have different font requirements.

    /// Get a reference to the font chain cache

    /// Get an embedded font by its hash (used for WebRender registration)

    /// Returns the FontRef if it exists in the embedded_fonts cache.

    /// Get a parsed font by its hash (used for WebRender registration)

    /// Returns the parsed font if it exists in the parsed_fonts cache.

        // Linear search through all cached fonts to find one with matching hash

        }

    /// Register an embedded FontRef for later lookup by hash

    /// This is called when using FontStack::Ref during shaping

    /// Get a snapshot of all currently loaded fonts

    ///

    /// This returns a copy of all parsed fonts, which can be passed to the shaper.

    /// No locking is required after this call - the returned HashMap is independent.

    ///

    /// NOTE: This should be called AFTER loading all required fonts for a layout pass.

    /// Get the set of FontIds that are currently loaded

    ///

    /// This is useful for computing which fonts need to be loaded

    /// (diff with required fonts).

        // M12.7: skip hashbrown's RawIterRange on an empty map — its NEON

        // control-byte group-scan mis-lifts to wasm and iterates forever

        // (the headless web layout uses an empty font cache → parsed is

        // empty here). is_empty() is len-based (no iteration), so it is safe.

    /// Insert a loaded font into the cache

    ///

    /// Returns the old font if one was already present for this FontId.

    /// Insert multiple loaded fonts into the cache

    ///

    /// This is more efficient than calling `insert_font` multiple times

    /// because it only acquires the lock once.

    /// One-shot helper that resolves "what fonts does `chains` need

    /// that this manager hasn't loaded yet" and loads them via the

    /// supplied `load_fn` closure (typically

    /// `PathLoader::load_font_shared` for the production lazy-decode

    /// path). Updates `parsed_fonts` in place and returns any failures

    /// for the caller to log.

    ///

    /// Replaces the same four-step `collect → compute_diff →

    /// load_from_disk → insert_fonts` dance previously inlined in

    /// `LayoutWindow::layout_document`, the CPU rasterizer pre-fill

    /// in `cpurender.rs`, and `FontContext::load_fonts_for_chains`.

    {

        use crate::solver3::getters::{

            collect_font_ids_from_chains, compute_fonts_to_load, load_fonts_from_disk,

        };

    /// Remove a font from the cache

    ///

    /// Returns the removed font if it was present.

}

// Error handling

#[derive(Debug, thiserror::Error)]

pub enum LayoutError {

    #[error("Bidi analysis failed: {0}")]

    BidiError(String),

    #[error("Shaping failed: {0}")]

    ShapingError(String),

    #[error("Font not found: {0:?}")]

    FontNotFound(FontSelector),

    #[error("Invalid text input: {0}")]

    InvalidText(String),

    #[error("Hyphenation failed: {0}")]

    HyphenationError(String),

}

/// Text boundary types for cursor movement

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

pub enum TextBoundary {

    /// Reached top of text (first line)

    Top,

    /// Reached bottom of text (last line)

    Bottom,

    /// Reached start of text (first character)

    Start,

    /// Reached end of text (last character)

    End,

}

/// Error returned when cursor movement hits a boundary

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

pub struct CursorBoundsError {

    /// The boundary that was hit

    pub boundary: TextBoundary,

    /// The cursor position (unchanged from input)

    pub cursor: TextCursor,

}

/// Unified constraints combining all layout features

///

/// # CSS Inline Layout Module Level 3: Constraint Mapping

///

/// This structure maps CSS properties to layout constraints:

///

/// ## \u00a7 2.1 Layout of Line Boxes

/// - `available_width`: \u26a0\ufe0f CRITICAL - Should equal containing block's inner width

///   * Currently defaults to 0.0 which causes immediate line breaking

///   * Per spec: "logical width of a line box is equal to the inner logical width of its containing

///     block"

/// - `available_height`: For block-axis constraints (max-height)

///

/// ## \u00a7 2.2 Layout Within Line Boxes

/// - `text_align`: \u2705 Horizontal alignment (start, end, center, justify)

/// - `vertical_align`: \u26a0\ufe0f PARTIAL - Only baseline supported, missing:

///   * top, bottom, middle, text-top, text-bottom

///   * <length>, <percentage> values

///   * sub, super positions

/// - `line_height`: \u2705 Distance between baselines

///

/// ## \u00a7 3 Baselines and Alignment Metrics

/// - `text_orientation`: \u2705 For vertical writing (sideways, upright)

/// - `writing_mode`: \u2705 horizontal-tb, vertical-rl, vertical-lr

/// - `direction`: \u2705 ltr, rtl for BiDi

///

/// ## \u00a7 4 Baseline Alignment (vertical-align property)

/// \u26a0\ufe0f INCOMPLETE: Only basic baseline alignment implemented

///

/// ## \u00a7 5 Line Spacing (line-height property)

/// - `line_height`: \u2705 Implemented

/// - \u274c MISSING: line-fit-edge for controlling which edges contribute to line height

/// +spec:box-model:51342f - inline box margins/borders/padding do not affect line box height (default leading mode)

/// +spec:font-metrics:618776 - line-fit-edge (cap, ex, ideographic, alphabetic edge selection) not yet implemented

///

/// ## \u00a7 6 Trimming Leading (text-box-trim)

/// - \u274c NOT IMPLEMENTED: text-box-trim property

/// - \u274c NOT IMPLEMENTED: text-box-edge property

/// +spec:box-model:c09331 - text-box-trim trims block container first/last line to font metrics

/// // +spec:overflow:dc2196 - text-box-trim overflow handled as normal overflow (no special handling needed)

///

/// ## CSS Text Module Level 3

/// - `text_indent`: \u2705 First line indentation

/// - `text_justify`: \u2705 Justification algorithm (auto, inter-word, inter-character)

/// - `hyphenation`: \u2705 Hyphens property (none / manual / auto)

/// - `hanging_punctuation`: \u2705 Hanging punctuation at line edges

///

/// ## CSS Text Level 4

/// - `text_wrap`: \u2705 balance, pretty, stable

/// - `line_clamp`: \u2705 Max number of lines

///

/// ## CSS Writing Modes Level 4

/// - `text_combine_upright`: \u2705 Tate-chu-yoko for vertical text

///

/// ## CSS Shapes Module

/// - `shape_boundaries`: \u2705 Custom line box shapes

/// - `shape_exclusions`: \u2705 Exclusion areas (float-like behavior)

/// - `exclusion_margin`: \u2705 Margin around exclusions

///

/// ## Multi-column Layout

/// - `columns`: \u2705 Number of columns

/// - `column_gap`: \u2705 Gap between columns

///

/// # Known Issues:

/// 1. [ISSUE] available_width defaults to Definite(0.0) instead of containing block width

/// 2. [ISSUE] vertical_align only supports baseline

/// 3. [TODO] initial-letter (drop caps) not implemented

// +spec:box-model:415ef3 - initial letters use standard margin/padding/border box model; exclusion area = margin box

// +spec:box-model:d53ea3 - when block-start padding+border are zero, content edge coincides with over alignment point

/// +spec:positioning:fb233a - initial letter block-axis: if size < sink, use over alignment

#[derive(Debug, Clone)]

pub struct UnifiedConstraints {

    // Shape definition

    pub shape_boundaries: Vec<ShapeBoundary>,

    pub shape_exclusions: Vec<ShapeBoundary>,

    // Basic layout - using AvailableSpace for proper indefinite handling

    pub available_width: AvailableSpace,

    pub available_height: Option<f32>,

    // Text layout

    pub writing_mode: Option<WritingMode>,

    // +spec:writing-modes:6c5ab9 - blocks inherit base direction from parent via CSS direction property

    // Base direction from CSS, overrides auto-detection

    pub direction: Option<BidiDirection>,

    pub text_orientation: TextOrientation,

    pub text_align: TextAlign,

    pub text_justify: JustifyContent,

    // +spec:display-property:3bcac8 - inline boxes sized in block axis based on font metrics (ascent/descent)

    pub line_height: LineHeight,

    pub vertical_align: VerticalAlign,

    // block container's first available font, used for minimum line box height

    pub strut_ascent: f32,

    pub strut_descent: f32,

    // x-height of the strut font (scaled to font_size), for vertical-align: middle

    pub strut_x_height: f32,

    // Width of '0' (zero) character in px, used for ch unit and tab-size.

    // Approximated as space_width from the first available font, or 0.5 * font_size fallback.

    pub ch_width: f32,

    // Overflow handling

    pub overflow: OverflowBehavior,

    pub segment_alignment: SegmentAlignment,

    // Advanced features

    pub text_combine_upright: Option<TextCombineUpright>,

    pub exclusion_margin: f32,

    pub hyphenation: Hyphens,

    pub hyphenation_language: Option<Language>,

    pub text_indent: f32,

    pub text_indent_each_line: bool,

    pub text_indent_hanging: bool,

    pub initial_letter: Option<InitialLetter>,

    pub line_clamp: Option<NonZeroUsize>,

    // text-wrap: balance

    pub text_wrap: TextWrap,

    pub columns: u32,

    pub column_gap: f32,

    pub hanging_punctuation: bool,

    pub overflow_wrap: OverflowWrap,

    pub text_align_last: TextAlign,

    // §5.2 word-break property on constraints

    pub word_break: WordBreak,

    pub white_space_mode: WhiteSpaceMode,

    pub line_break: LineBreakStrictness,

    // CSS unicode-bidi property; Plaintext causes per-paragraph auto-detection

    pub unicode_bidi: UnicodeBidi,

}

impl Default for UnifiedConstraints {

}

// UnifiedConstraints

impl Hash for UnifiedConstraints {

}

impl PartialEq for UnifiedConstraints {

            }

}

impl Eq for UnifiedConstraints {}

impl UnifiedConstraints {

    /// Resolve `line_height` to a pixel value using the strut metrics as a font-size proxy.

    /// `strut_ascent + strut_descent` approximates `font_size` (the block container's font).

        }

            Some(WritingMode::VerticalRl) | Some(WritingMode::VerticalLr)

        )

}

/// Line constraints with multi-segment support

#[derive(Debug, Clone)]

pub struct LineConstraints {

    pub segments: Vec<LineSegment>,

    pub total_available: f32,

}

impl WritingMode {

            // determined by text content

        }

}

// Stage 1: Collection - Styled runs from DOM traversal

#[derive(Debug, Clone, Hash)]

pub struct StyledRun {

    pub text: String,

    pub style: Arc<StyleProperties>,

    /// Byte index in the original logical paragraph text

    pub logical_start_byte: usize,

    /// The DOM NodeId of the Text node this run came from.

    /// None for generated content (e.g., list markers, ::before/::after).

    pub source_node_id: Option<NodeId>,

}

// Stage 2: Bidi Analysis - Visual runs in display order

#[derive(Debug, Clone)]

pub struct VisualRun<'a> {

    pub text_slice: &'a str,

    pub style: Arc<StyleProperties>,

    pub logical_start_byte: usize,

    pub bidi_level: BidiLevel,

    pub script: Script,

    pub language: Language,

}

// Font and styling types

/// A selector for loading fonts from the font cache.

/// Used by FontManager to query fontconfig and load font files.

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

pub struct FontSelector {

    pub family: String,

    pub weight: FcWeight,

    pub style: FontStyle,

    pub unicode_ranges: Vec<UnicodeRange>,

}

impl Default for FontSelector {