//! Layout tree construction from a styled DOM, including anonymous box generation

use std::{

    collections::BTreeMap,

    hash::{Hash, Hasher},

    sync::{

        atomic::{AtomicU32, Ordering},

        Arc,

    },

};

use azul_core::diff::NodeDataFingerprint;

use crate::text3::cache::UnifiedConstraints;

/// Global counter for IFC IDs. Resets to 0 when layout() callback is invoked.

static IFC_ID_COUNTER: AtomicU32 = AtomicU32::new(0);

/// Unique identifier for an Inline Formatting Context (IFC).

///

/// An IFC represents a region where inline content (text, inline-blocks, images)

/// is laid out together. One IFC can contain content from multiple DOM nodes

/// (e.g., `<p>Hello <span>world</span>!</p>` is one IFC with 3 text runs).

///

/// The ID is generated using a global atomic counter that resets at the start

/// of each layout pass. This ensures:

/// - IDs are unique within a layout pass

/// - The same logical IFC gets the same ID across frames (for selection stability)

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

pub struct IfcId(pub u32);

impl IfcId {

    /// Generate a new unique IFC ID.

    /// Reset the IFC ID counter. Called at the start of each layout pass.

}

/// Tracks a layout node's membership in an Inline Formatting Context.

///

/// Text nodes don't store their own `inline_layout_result` - instead, they

/// participate in their parent's IFC. This struct provides the link from

/// a text node back to its IFC's layout data.

///

/// # Architecture

///

/// ```text

/// DOM:  <p>Hello <span>world</span>!</p>

///

/// Layout Tree:

/// ├── LayoutNode (p) - IFC root

/// │   └── inline_layout_result: Some(UnifiedLayout)

/// │   └── ifc_id: IfcId(5)

/// │

/// ├── LayoutNode (::text "Hello ")

/// │   └── ifc_membership: Some(IfcMembership { ifc_id: 5, run_index: 0 })

/// │

/// ├── LayoutNode (span)

/// │   └── ifc_membership: Some(IfcMembership { ifc_id: 5, run_index: 1 })

/// │   └── LayoutNode (::text "world")

/// │       └── ifc_membership: Some(IfcMembership { ifc_id: 5, run_index: 1 })

/// │

/// └── LayoutNode (::text "!")

///     └── ifc_membership: Some(IfcMembership { ifc_id: 5, run_index: 2 })

/// ```

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

pub struct IfcMembership {

    /// The IFC ID this node's content was laid out in.

    pub ifc_id: IfcId,

    /// The index of the IFC root LayoutNode in the layout tree.

    /// Used to quickly find the node with `inline_layout_result`.

    pub ifc_root_layout_index: usize,

    /// Which run index within the IFC corresponds to this node's text.

    /// Maps to `ContentIndex::run_index` in the shaped items.

    pub run_index: u32,

}

use azul_core::{

    dom::{FormattingContext, NodeData, NodeId, NodeType},

    geom::{LogicalPosition, LogicalRect, LogicalSize},

    styled_dom::StyledDom,

};

use azul_css::{

    corety::LayoutDebugMessage,

    css::CssPropertyValue,

    codegen::format::GetHash,

    props::{

        basic::{

            pixel::DEFAULT_FONT_SIZE, PhysicalSize, PixelValue, PropertyContext, ResolutionContext,

        },

        layout::{

            LayoutDisplay, LayoutFloat, LayoutHeight, LayoutMaxHeight, LayoutMaxWidth,

            LayoutMinHeight, LayoutMinWidth, LayoutOverflow, LayoutPosition, LayoutWidth,

            LayoutWritingMode,

        },

        property::{CssProperty, CssPropertyType},

        style::{StyleTextAlign, StyleWhiteSpace},

    },

};

use taffy::{Cache as TaffyCache, Layout, LayoutInput, LayoutOutput};

#[cfg(feature = "text_layout")]

use crate::text3;

use crate::{

    debug_log,

    font::parsed::ParsedFont,

    font_traits::{FontLoaderTrait, ParsedFontTrait, UnifiedLayout},

    solver3::{

        geometry::{BoxProps, IntrinsicSizes, PositionedRectangle},

        getters::{

            get_css_height, get_css_max_height, get_css_max_width, get_css_min_height,

            get_css_min_width, get_css_width, get_direction_property as get_direction,

            get_display_property, get_float, get_overflow_x,

            get_overflow_y, get_position, get_text_align,

            get_text_orientation_property as get_text_orientation,

            get_white_space_property, get_writing_mode, MultiValue,

        },

        scrollbar::ScrollbarRequirements,

        LayoutContext, Result,

    },

    text3::cache::AvailableSpace,

};

/// Represents the invalidation state of a layout node.

///

/// The states are ordered by severity, allowing for easy "upgrading" of the dirty state.

/// A node marked for `Layout` does not also need to be marked for `Paint`.

///

/// Because this enum derives `PartialOrd` and `Ord`, you can directly compare variants:

///

/// - `DirtyFlag::Layout > DirtyFlag::Paint` is `true`

/// - `DirtyFlag::Paint >= DirtyFlag::None` is `true`

/// - `DirtyFlag::Paint < DirtyFlag::Layout` is `true`

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

pub enum DirtyFlag {

    /// The node's layout is valid and no repaint is needed. This is the "clean" state.

    #[default]

    None,

    /// The node's geometry is valid, but its appearance (e.g., color) has changed.

    /// Requires a display list update only.

    Paint,

    /// The node's geometry (size or position) is invalid.

    /// Requires a full layout pass and a display list update.

    Layout,

}

/// A hash that represents the content and style of a node PLUS all of its descendants.

/// If two SubtreeHashes are equal, their entire subtrees are considered identical for layout

/// purposes.

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

pub struct SubtreeHash(pub u64);

/// Per-item metrics cached from the last IFC layout.

///

/// These metrics enable incremental IFC relayout (Phase 2 optimization):

/// when a single inline item changes, we can check whether its advance width

/// changed and potentially skip full line-breaking for unaffected lines.

///

/// Index in `CachedInlineLayout::item_metrics` matches the item order in

/// `UnifiedLayout::items`.

#[derive(Debug, Clone)]

pub struct InlineItemMetrics {

    /// The DOM NodeId of the source node for this item (for dirty checking).

    /// `None` for generated content (list markers, hyphens, etc.)

    pub source_node_id: Option<NodeId>,

    /// Advance width of this item (glyph run width, inline-block width, etc.)

    pub advance_width: f32,

    /// Advance height contribution from this item to its line box.

    pub line_height_contribution: f32,

    /// Whether this item can participate in line breaking.

    /// `false` for items inside `white-space: nowrap` or `white-space: pre`.

    pub can_break: bool,

    /// Which line this item was placed on (0-indexed).

    pub line_index: u32,

    /// X offset within its line.

    pub x_offset: f32,

}

/// Cached inline layout result with the constraints used to compute it.

///

/// This structure solves a fundamental architectural problem: inline layouts

/// (text wrapping, inline-block positioning) depend on the available width.

/// Different layout phases may compute the layout with different widths:

///

/// 1. **Min-content measurement**: width = MinContent (effectively 0)

/// 2. **Max-content measurement**: width = MaxContent (effectively infinite)

/// 3. **Final layout**: width = Definite(actual_column_width)

///

/// Without tracking which constraints were used, a cached result from phase 1

/// would incorrectly be reused in phase 3, causing text to wrap at the wrong

/// positions (the root cause of table cell width bugs).

///

/// By storing the constraints alongside the result, we can:

/// - Invalidate the cache when constraints change

/// - Keep multiple cached results for different constraint types if needed

/// - Ensure the final render always uses a layout computed with correct widths

#[derive(Debug, Clone)]

pub struct CachedInlineLayout {

    /// The computed inline layout

    pub layout: Arc<UnifiedLayout>,

    /// The available width constraint used to compute this layout.

    /// This is the key for cache validity checking.

    /// +spec:writing-modes:1dcba2 - "available width" (CSS2.1) = auto size in inline axis

    pub available_width: AvailableSpace,

    /// Whether this layout was computed with float exclusions.

    /// Float-aware layouts should not be overwritten by non-float layouts.

    pub has_floats: bool,

    /// The full constraints used to compute this layout.

    /// Used for quick relayout after text edits without rebuilding from CSS.

    pub constraints: Option<UnifiedConstraints>,

    /// Per-item metrics for incremental IFC relayout (Phase 2).

    ///

    /// Each entry corresponds to one `PositionedItem` in `layout.items`.

    /// These metrics enable the IFC relayout decision tree:

    /// - Check if a dirty node's advance_width changed → skip repositioning if not

    /// - Use `can_break` + `line_index` for the nowrap fast path

    /// - Use `x_offset` for shifting subsequent items without full line-breaking

    pub item_metrics: Vec<InlineItemMetrics>,

    /// Cached line break boundaries for incremental relayout.

    /// Enables checking if a width change fits on the same line without

    /// re-running the full line-breaking algorithm.

    pub line_breaks: Option<crate::text3::cache::CachedLineBreaks>,

    /// Hash of the `InlineContent` this layout was shaped from. The Phase 2d

    /// fast-path reuse in fc.rs keys cache validity on WIDTH only; without this,

    /// a same-width RefreshDom whose text CHANGED would reuse the stale shaped

    /// layout (#11 stale display list). 0 = unknown ⇒ never fast-path-reuse.

    pub inline_content_hash: u64,

}

impl CachedInlineLayout {

    /// Creates a new cached inline layout.

    /// Creates a new cached inline layout with full constraints.

        };

    /// Extracts per-item metrics from a computed `UnifiedLayout`.

    ///

    /// This is called automatically by the constructors. The metrics

    /// enable incremental IFC relayout in Phase 2c/2d by providing

    /// cached advance widths, line assignments, and break information

    /// for each positioned item.

        use crate::text3::cache::{ShapedItem, get_item_vertical_metrics_approx};

                // Objects (inline-blocks, images) and other generated items

                // don't expose source_node_id directly on ShapedItem.

                // Phase 2c will refine this via the ContentIndex mapping.

                ShapedItem::Object { .. }

                | ShapedItem::CombinedBlock { .. }

                | ShapedItem::Tab { .. }

            };

            // For Phase 2a, default can_break = true for all items.

            // Phase 2c will refine this by checking the white-space property

            // on the IFC root's style or the item's own style context.

            // (Note: text3::StyleProperties doesn't carry white-space;

            //  that's resolved at the IFC/BFC boundary level.)

    /// Checks if this cached layout is valid for the given constraints.

    ///

    /// A cached layout is valid if:

    /// 1. The available width matches (definite widths must be equal, or both are the same

    ///    indefinite type)

    /// 2. OR the new request doesn't have floats but the cached one does (keep float-aware layout)

    ///

    /// The second condition preserves float-aware layouts, which are more "correct" than

    /// non-float layouts and shouldn't be overwritten.

        // If we have a float-aware layout and the new request doesn't have floats,

        // keep the float-aware layout (it's more accurate)

            // But only if the width constraint type matches

        // Otherwise, require exact width match

    /// Tolerance for comparing definite layout widths (in logical pixels).

    /// Sub-pixel differences below this threshold are treated as identical

    /// to avoid unnecessary relayout from floating-point rounding.

    const LAYOUT_WIDTH_EPSILON: f32 = 0.1;

    /// Checks if the width constraint matches.

            // Definite widths must match within a small epsilon

            }

            // MinContent matches MinContent

            // MaxContent matches MaxContent

            // Different constraint types don't match

        }

    /// Determines if this cached layout should be replaced by a new layout.

    ///

    /// Returns true if the new layout should replace this one.

        // Always replace if we gain float information

        // Replace if width constraint changed

    /// Returns a reference to the inner UnifiedLayout.

    ///

    /// This is a convenience method for code that only needs the layout data

    /// and doesn't care about the caching metadata.

    #[inline]

    /// Returns a clone of the inner Arc<UnifiedLayout>.

    ///

    /// This is useful for APIs that need to return an owned reference

    /// to the layout without exposing the caching metadata.

    #[inline]

}

/// A layout tree node representing the CSS box model.

///

/// ## Memory Layout Optimization (`#[repr(C)]`)

///

/// Fields are ordered by access frequency (hottest first) to maximize CPU

/// cache line utilization during tree traversal. With `#[repr(C)]`, the

/// compiler preserves this ordering. The 6 hottest fields (~140 bytes)

/// occupy the first 2-3 cache lines (64 bytes each), which are loaded

/// first by the hardware prefetcher.

///

/// | Tier   | Fields                                  | ~Bytes | Accesses |

/// |--------|-----------------------------------------|--------|----------|

/// | HOT    | box_props, dom_node_id, children,       |  ~140  |  410+    |

/// |        | used_size, formatting_context, parent    |        |          |

/// | WARM   | intrinsic_sizes..computed_style          |  ~220  |  ~80     |

/// | COLD   | dirty_flag..is_anonymous                 |  ~190  |  ~20     |

///

/// Note: An absolute position is a final paint-time value and shouldn't be

/// cached on the node itself, as it can change even if the node's

/// layout is clean (e.g., if a sibling changes size). We will calculate

/// it in a separate map.

#[derive(Debug, Clone)]

#[repr(C)]

pub struct LayoutNode {

    // ── HOT tier: accessed on every node in every layout pass ────────────

    // These fields should fit in the first 2-3 cache lines (~128-192 bytes).

    /// The resolved box model properties (margin, border, padding)

    /// in logical pixels. Cached after first resolution.

    /// (148 accesses — hottest field)

    pub box_props: BoxProps,

    /// Reference back to the original DOM node (None for anonymous boxes)

    /// (111 accesses)

    pub dom_node_id: Option<NodeId>,

    /// Children indices in the layout tree

    /// (53 accesses)

    pub children: Vec<usize>,

    /// The size used during the last layout pass.

    /// (43 accesses)

    pub used_size: Option<LogicalSize>,

    /// The formatting context this node establishes or participates in.

    /// (30 accesses)

    pub formatting_context: FormattingContext,

    /// Parent index (None for root)

    /// (25 accesses)

    pub parent: Option<usize>,

    // ── WARM tier: frequently accessed but not on every node ─────────────

    /// Cached intrinsic sizes (min-content, max-content, etc.)

    /// (16 accesses — sizing pass only)

    pub intrinsic_sizes: Option<IntrinsicSizes>,

    // +spec:display-property:af3a89 - alignment baseline for inline-level boxes

    /// The baseline of this box, if applicable, measured from its content-box top edge.

    /// (14 accesses — IFC/table alignment)

    pub baseline: Option<f32>,

    /// Cached inline layout result with the constraints used to compute it.

    ///

    /// This field stores both the computed layout AND the constraints (available width,

    /// float state) under which it was computed. This is essential for correctness:

    /// 

    /// - Table cells are measured multiple times with different widths

    /// - Min-content/max-content intrinsic sizing uses special constraint values

    /// - The final layout must use the actual available width, not a measurement width

    ///

    /// By tracking the constraints, we avoid the bug where a min-content measurement

    /// (with width=0) would be incorrectly reused for final rendering.

    /// (13 accesses — IFC roots / table cells)

    pub inline_layout_result: Option<CachedInlineLayout>,

    /// Cached scrollbar information (calculated during layout)

    /// Used to determine if scrollbars appeared/disappeared requiring reflow

    /// (12 accesses — scrollable containers only)

    pub scrollbar_info: Option<ScrollbarRequirements>,

    /// The position of this node *relative to its parent's content box*.

    /// (9 accesses — positioning pass)

    pub relative_position: Option<LogicalPosition>,

    /// The actual content size (children overflow size) for scrollable containers.

    /// This is the size of all content that might need to be scrolled, which can

    /// be larger than `used_size` when content overflows the container.

    /// (7 accesses — scrollable containers)

    pub overflow_content_size: Option<LogicalSize>,

    /// Cache for Taffy layout computations for this node.

    /// (6 accesses — Taffy bridge)

    pub taffy_cache: TaffyCache,

    /// Pre-computed CSS properties needed during layout.

    /// Computed once during layout tree build to avoid repeated style lookups.

    /// (5 accesses — cache.rs only)

    pub computed_style: ComputedLayoutStyle,

    /// Pseudo-element type (::marker, ::before, ::after) if this node is a pseudo-element

    /// (5 accesses — pseudo-elements only)

    pub pseudo_element: Option<PseudoElement>,

    /// Escaped top margin (CSS 2.1 margin collapsing)

    /// If this BFC's first child's top margin "escaped" the BFC, this contains

    /// the collapsed margin that should be applied by the parent.

    /// (4 accesses — BFC margin collapsing)

    pub escaped_top_margin: Option<f32>,

    /// Escaped bottom margin (CSS 2.1 margin collapsing)  

    /// If this BFC's last child's bottom margin "escaped" the BFC, this contains

    /// the collapsed margin that should be applied by the parent.

    /// (4 accesses)

    pub escaped_bottom_margin: Option<f32>,

    /// Parent's formatting context (needed to determine if stretch applies)

    /// (4 accesses — flex/grid children)

    pub parent_formatting_context: Option<FormattingContext>,

    /// If this node participates in an IFC (is inline content like text),

    /// stores the reference back to the IFC root and the run index.

    /// This allows text nodes to find their layout data in the parent's IFC.

    /// (3 accesses — text nodes only)

    pub ifc_membership: Option<IfcMembership>,

    /// The layout tree index of this node's containing block.

    /// - For abs-pos elements: nearest positioned (non-static) ancestor

    /// - For fixed elements: root / None (viewport)

    /// - For normal-flow: parent (None = implicit)

    /// Used for clip exemption: abs-pos elements whose containing block

    /// is above an overflow clipper should not be clipped.

    pub containing_block_index: Option<usize>,

    // ── COLD tier: construction / reconciliation / debugging only ────────

    /// Type of anonymous box (if applicable)

    /// (2 accesses)

    pub anonymous_type: Option<AnonymousBoxType>,

    /// Multi-field fingerprint of this node's data (style, text, etc.)

    /// for granular change detection during reconciliation.

    /// (2 accesses — reconciliation only)

    pub node_data_fingerprint: NodeDataFingerprint,

    /// A hash of this node's data and all of its descendants. Used for

    /// fast reconciliation.

    /// (9 accesses — all in cache.rs reconciliation)

    pub subtree_hash: SubtreeHash,

    /// Dirty flags to track what needs recalculation.

    /// (7 accesses — reconciliation setup)

    pub dirty_flag: DirtyFlag,

    /// Unresolved box model properties (raw CSS values).

    /// These are resolved lazily during layout when containing block is known.

    /// (1 access — initial resolution only)

    pub unresolved_box_props: crate::solver3::geometry::UnresolvedBoxProps,

    /// If this node is an IFC root, stores the IFC ID.

    /// Used to identify which IFC this node's `inline_layout_result` belongs to.

    /// (1 access — IFC creation only)

    pub ifc_id: Option<IfcId>,

}

/// Pre-computed CSS properties needed during layout.

/// 

/// This struct stores resolved CSS values that are frequently accessed during

/// layout calculations. By computing these once during layout tree construction,

/// we avoid O(n * m) style lookups where n = nodes and m = layout passes.

///

/// All values are resolved to their final form (no 'inherit', 'initial', etc.)

#[derive(Debug, Clone, Default)]

pub struct ComputedLayoutStyle {

    /// CSS `display` property

    pub display: LayoutDisplay,

    /// CSS `position` property

    pub position: LayoutPosition,

    /// CSS `float` property

    pub float: LayoutFloat,

    /// CSS `overflow-x` property

    pub overflow_x: LayoutOverflow,

    /// CSS `overflow-y` property

    pub overflow_y: LayoutOverflow,

    /// CSS `writing-mode` property

    pub writing_mode: azul_css::props::layout::LayoutWritingMode,

    /// CSS `direction` property (ltr/rtl)

    pub direction: azul_css::props::style::StyleDirection,

    /// CSS `text-orientation` property (for vertical writing modes)

    pub text_orientation: azul_css::props::style::effects::StyleTextOrientation,

    /// CSS `width` property (None = auto)

    pub width: Option<azul_css::props::layout::LayoutWidth>,

    /// CSS `height` property (None = auto)

    pub height: Option<azul_css::props::layout::LayoutHeight>,

    /// CSS `min-width` property

    pub min_width: Option<azul_css::props::layout::LayoutMinWidth>,

    /// CSS `min-height` property

    pub min_height: Option<azul_css::props::layout::LayoutMinHeight>,

    /// CSS `max-width` property

    pub max_width: Option<azul_css::props::layout::LayoutMaxWidth>,

    /// CSS `max-height` property

    pub max_height: Option<azul_css::props::layout::LayoutMaxHeight>,

    /// CSS `text-align` property

    pub text_align: azul_css::props::style::StyleTextAlign,

}

// Note: LayoutNode methods that cross hot/warm/cold boundaries have been

// moved to LayoutTree methods (resolve_box_props, get_content_size).

/// CSS pseudo-elements that can be generated

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

pub enum PseudoElement {

    /// ::marker pseudo-element for list items

    Marker,

    /// ::before pseudo-element

    Before,

    /// ::after pseudo-element

    After,

}

// +spec:display-property:b7f4bf - anonymous inline/block boxes are both called "anonymous boxes"

/// Types of anonymous boxes that can be generated

// +spec:display-property:ae4f16 - anonymous boxes are treated as descendants alongside pseudo-elements

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

pub enum AnonymousBoxType {

    /// Anonymous block box wrapping inline content

    InlineWrapper,

    /// Anonymous box for a list item marker (bullet or number)

    /// DEPRECATED: Use PseudoElement::Marker instead

    ListItemMarker,

    /// Anonymous table wrapper

    TableWrapper,

    /// Anonymous table row group (tbody)

    TableRowGroup,

    /// Anonymous table row

    TableRow,

    /// Anonymous table cell

    TableCell,

}

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

// SoA (struct-of-arrays) layout node split for cache performance

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

/// Hot layout node fields — accessed on every node in every layout pass.

///

/// Stored in a separate `Vec` for cache locality. At ~100 bytes per node,

/// 1000 nodes fit in ~100 KB (L2 cache), vs ~550 KB with the monolithic struct.

#[derive(Debug, Clone)]

pub struct LayoutNodeHot {

    /// The resolved box model properties (margin, border, padding)

    /// Stored in packed i16×10 encoding to reduce cache footprint.

    /// Use `box_props.unpack()` to get f32 `ResolvedBoxProps` for computation.

    pub box_props: crate::solver3::geometry::PackedBoxProps,

    /// Reference back to the original DOM node (None for anonymous boxes)

    pub dom_node_id: Option<NodeId>,

    /// The size used during the last layout pass.

    pub used_size: Option<LogicalSize>,

    /// The formatting context this node establishes or participates in.

    pub formatting_context: FormattingContext,

    /// Parent index (None for root)

    pub parent: Option<usize>,

}

/// Warm layout node fields — accessed frequently but not on every node.

///

/// Stored in a separate `Vec`. These fields are accessed during specific

/// layout phases (sizing, IFC, table alignment) but not during the main

/// constraint-solving loop.

#[derive(Debug, Clone, Default)]

pub struct LayoutNodeWarm {

    /// Cached intrinsic sizes (min-content, max-content, etc.)

    pub intrinsic_sizes: Option<IntrinsicSizes>,

    /// The baseline of this box, measured from its content-box top edge.

    pub baseline: Option<f32>,

    /// Cached inline layout result with the constraints used to compute it.

    pub inline_layout_result: Option<CachedInlineLayout>,

    /// Cached scrollbar information

    pub scrollbar_info: Option<ScrollbarRequirements>,

    /// The position relative to parent's content box.

    pub relative_position: Option<LogicalPosition>,

    /// The actual content size for scrollable containers.

    pub overflow_content_size: Option<LogicalSize>,

    /// Cache for Taffy layout computations.

    pub taffy_cache: TaffyCache,

    /// Pre-computed CSS properties needed during layout.

    pub computed_style: ComputedLayoutStyle,

    /// Pseudo-element type if this node is a pseudo-element

    pub pseudo_element: Option<PseudoElement>,

    /// Escaped top margin (CSS 2.1 margin collapsing)

    pub escaped_top_margin: Option<f32>,

    /// Escaped bottom margin (CSS 2.1 margin collapsing)

    pub escaped_bottom_margin: Option<f32>,

    /// Parent's formatting context

    pub parent_formatting_context: Option<FormattingContext>,

    /// IFC membership for text nodes

    pub ifc_membership: Option<IfcMembership>,

    /// Containing block index for clip exemption

    pub containing_block_index: Option<usize>,

}

/// Cold layout node fields — construction / reconciliation / debugging only.

///

/// Stored in a separate `Vec`. These fields are rarely accessed during layout;

/// mostly used during tree construction, reconciliation, and dirty tracking.

#[derive(Debug, Clone)]

pub struct LayoutNodeCold {

    /// Type of anonymous box (if applicable)

    pub anonymous_type: Option<AnonymousBoxType>,

    /// Multi-field fingerprint for granular change detection.

    pub node_data_fingerprint: NodeDataFingerprint,

    /// Hash of this node's data + all descendants.

    pub subtree_hash: SubtreeHash,

    /// Dirty flags for recalculation tracking.

    pub dirty_flag: DirtyFlag,

    /// Unresolved box model properties (raw CSS values).

    pub unresolved_box_props: crate::solver3::geometry::UnresolvedBoxProps,

    /// IFC ID if this node is an IFC root.

    pub ifc_id: Option<IfcId>,

}

impl Default for LayoutNodeCold {

}

impl LayoutNode {

    /// Split this full layout node into hot/warm/cold components.

    /// Used during `LayoutTreeBuilder::build()` to create the SoA layout.

}

/// The complete layout tree structure.

///

/// Uses a struct-of-arrays (SoA) layout for cache performance:

/// - `nodes` (hot): accessed on every node in every layout pass

/// - `warm`: accessed during specific layout phases

/// - `cold`: construction / reconciliation only

#[derive(Debug, Clone)]

pub struct LayoutTree {

    /// Hot layout data — box props, parent, used_size, formatting context

    pub nodes: Vec<LayoutNodeHot>,

    /// Warm layout data — intrinsic sizes, baseline, inline layout, etc.

    pub warm: Vec<LayoutNodeWarm>,

    /// Cold layout data — dirty flags, fingerprints, reconciliation data

    pub cold: Vec<LayoutNodeCold>,

    /// Root node index

    pub root: usize,

    /// Mapping from DOM node IDs to layout node indices

    // BTreeMap (not HashMap): std HashMap's RandomState hasher needs an RNG seed

    // that isn't available in the remill-lifted wasm (no getrandom), so inserts

    // silently no-op there — dom_to_layout came back empty (node mapping lost,

    // get_node_size/position returned None → 0-rects). BTreeMap is deterministic,

    // matches the rest of azul-core, and lifts reliably (M12.7).

    pub dom_to_layout: BTreeMap<NodeId, Vec<usize>>,

    /// Flat arena holding all children indices contiguously.

    pub children_arena: Vec<usize>,

    /// Per-node (start, len) into `children_arena`. Indexed by node index.

    pub children_offsets: Vec<(u32, u32)>,

    /// Per-node bit: this node or any descendant establishes a shrink-to-fit

    /// (STF) context whose sizing algorithm reads children's intrinsic sizes

    /// (flex/grid/table/inline-block containers, floats, or abspos elements).

    ///

    /// If `subtree_needs_intrinsic[i]` is false AND no ancestor of `i` is STF

    /// either, the intrinsic sizing pass can skip the entire subtree — nothing

    /// will ever read those values. This is the static-DOM optimization from

    /// §58 Win #3 (the "safely re-enabled Fix C").

    ///

    /// Computed once at tree build time in `generate_layout_tree`. An empty

    /// vec means "assume every subtree needs intrinsics" (safe fallback for

    /// code paths that construct `LayoutTree` without going through the

    /// builder — currently none, but preserves the invariant for tests).

    pub subtree_needs_intrinsic: Vec<bool>,

}

/// Approximate per-field heap-byte breakdown of a [`LayoutTree`].

#[derive(Debug, Clone, Default)]

pub struct LayoutTreeMemoryReport {

    pub node_count: usize,

    pub hot_bytes: usize,

    pub warm_bytes: usize,

    pub warm_inline_layout_bytes: usize,

    pub warm_taffy_cache_bytes: usize,

    pub cold_bytes: usize,

    pub dom_to_layout_bytes: usize,

    pub children_arena_bytes: usize,

    pub children_offsets_bytes: usize,

}

impl LayoutTreeMemoryReport {

}

impl LayoutTree {

    /// Approximate heap bytes retained by this LayoutTree.

        // HashMap<NodeId, Vec<usize>> — approximate: (key + Vec-header) per entry

        // plus heap for each inner Vec.

        // Inline layout data lives behind Arc — count Arc heap-shares once

        // per node that has a cached layout. Counted conservatively.

                // Arc<UnifiedLayout> — count the UnifiedLayout header + its items.

                // Glyph bytes inside ShapedItem::Cluster — unbounded but bounded

                // per entry. Approximate by counting clusters × 32 bytes/glyph.

                }

            // Taffy cache — each slot is an Option, ~50 B empty

        }

    /// Returns the children of node `index` as a contiguous slice from the arena.

    #[inline]

        } else {

        }

    /// Get hot layout data for a node (box_props, dom_node_id, used_size, etc.)

    #[inline]

    /// Get mutable hot layout data for a node.

    #[inline]

    /// Get warm layout data for a node (intrinsic_sizes, baseline, inline_layout, etc.)

    #[inline]

    /// Get mutable warm layout data for a node.

    #[inline]

    /// Get cold layout data for a node (dirty_flag, subtree_hash, fingerprint, etc.)

    #[inline]

    /// Get mutable cold layout data for a node.

    #[inline]

    /// Reconstruct a full `LayoutNode` from the split hot/warm/cold arrays.

    ///

    /// Used when passing node data to `LayoutTreeBuilder::clone_node_from_old()`.

    /// Re-resolve box properties for a node with the actual containing block size.

    /// Marks a node and its ancestors as dirty with the given flag.

            };

        }

    /// Marks a node and its entire subtree of descendants with the given dirty flag.

        }

    /// Resets the dirty flags of all nodes in the tree to `None` after layout is complete.

    /// Get inline layout for a node, navigating through IFC membership if needed.

        // First, check if this node has its own inline_layout_result (it's an IFC root)

        // For text nodes, check if they have ifc_membership pointing to the IFC root

    /// Return the layout index of the IFC root that owns `layout_index`'s inline content.

    /// If the node IS an IFC root (has its own `inline_layout_result`) or has no

    /// `ifc_membership`, returns `layout_index` unchanged. Inline text nodes never get

    /// their own box position (it stays the `f32::MIN` sentinel) — their geometry lives

    /// in the IFC root's content box, so selection/inline painting must anchor to the

    /// IFC root's position, not the text node's. See `get_inline_layout_for_node`.

    /// Get the content size of a node (for scrollbar calculations).

        };

        };

}

/// Generate layout tree from styled DOM with proper anonymous box generation

    // Pre-compute the STF (shrink-to-fit) subtree bitmap. This is static-DOM

    // information: whether a subtree establishes any shrink-to-fit context

    // depends only on the DOM structure + formatting context, both of which

    // are frozen from here until the next layout-tree rebuild. The intrinsic

    // sizing pass reads this to skip subtrees whose intrinsics are never

    // consumed (§58 Win #3).

    );

/// Returns true if `(dom_node_id, fc)` establishes a formatting context whose

/// sizing algorithm reads children's intrinsic sizes. Covers:

/// - flex containers (flex item sizing uses child min/max-content),

/// - grid containers (grid-track sizing likewise),

/// - tables and table cells,

/// - inline-block (its own width may be shrink-to-fit),

/// - floats and abspos elements (their `auto` width resolves to shrink-to-fit).

///

/// A `FormattingContext::Block` with a definite CSS width is NOT shrink-to-fit —

/// its inner layout gets the width top-down, so descendant intrinsics don't

/// feed back up. That's the path Fix C short-circuits.

    use crate::solver3::getters::{get_float, MultiValue};

    use crate::solver3::positioning::get_position_type;

    use azul_css::props::layout::{LayoutFloat, LayoutPosition};

        FormattingContext::Flex

        | FormattingContext::Grid

        | FormattingContext::Table

    }

    };

        // Abspos only becomes shrink-to-fit when width is `auto`.

        // Being conservative: treat as STF whenever abspos so we still

        // compute intrinsics for the auto-width case. Misses no work.

/// Per-node bitmap of "this node or any descendant establishes a shrink-to-fit

/// context." Post-order walk: `out[i] = self_stf(i) || any(out[child_of_i])`.

/// Layout tree nodes are built top-down (pre-order), so iterating from the end

/// visits children before parents.

            }

    }

/// Incrementally builds a [`LayoutTree`] from a [`StyledDom`].

///

/// Usage: create via [`LayoutTreeBuilder::new`], call [`process_node`](Self::process_node)

/// on the root DOM node, then call [`build`](Self::build) to produce the final

/// SoA-split `LayoutTree`. During `process_node`, anonymous boxes are generated

/// as required by CSS 2.2 §9.2.1.1 (inline wrappers) and §17.2.1 (table fixup).

pub struct LayoutTreeBuilder {

    nodes: Vec<LayoutNode>,

    dom_to_layout: BTreeMap<NodeId, Vec<usize>>,

    viewport_size: LogicalSize,

}

impl LayoutTreeBuilder {

    // +spec:display-property:2188b7 - builds box tree: each element's principal box is child of nearest ancestor's principal box, with anonymous boxes for tables/inline wrapping

    /// Main entry point for recursively building the layout tree.

    /// This function dispatches to specialized handlers based on the node's

    /// `display` property to correctly generate anonymous boxes.

        // +spec:display-property:042f56 - replaced elements with layout-internal display use inline

        // CSS Display 3 §2.4: "When the display property of a replaced element computes to

        // one of the layout-internal values, it is handled as having a used value of inline."

        } else {

        };

        // +spec:display-property:0b40af - display/position/float interaction per CSS 2.2 §9.7

        // +spec:display-property:ba53ba - float!=none or position!=static causes display to blockify

        // +spec:positioning:69468c - absolute/fixed blockifies the box, float computes to none

        // +spec:table-layout:cfc60a - CSS 2.2 §9.7: display/position/float interaction

        // Blockification rules (CSS Display 3 §2.7 / §2.8):

        // 1. Root element → blockify

        // 2. position:absolute or position:fixed → float computes to 'none', blockify

        // 3. float is not 'none' → blockify

        // 4. Flex/Grid children → blockify

        // Per CSS 2.2 §9.7: if position is absolute or fixed, float computes to 'none'

        );

        // If blockification changed the display type, update the node's formatting context

        // Compute containing block index for abs-pos clip exemption

                // Fixed elements: containing block is the root (viewport)

            } else {

                // Absolute elements: containing block is nearest positioned ancestor

                loop {

                        }

                    }

                }

            };

        // +spec:display-property:1f4039 - list-item generates ::marker pseudo-element + principal box

        // +spec:display-property:2bb592 - list-item generates ::marker pseudo-element with list-style content

        // +spec:display-property:3b507e - list-item generates ::marker pseudo-element

        // +spec:display-property:a48f00 - additional boxes (marker, table wrapper) placed w.r.t. principal box

        // +spec:display-property:998063 - list-item generates principal block box + marker box

        // If this is a list-item, inject a ::marker pseudo-element as its first child

        // +spec:display-property:a42905 - list-item generates ::marker pseudo-element with list-style content, principal box outer=block inner=flow