//! CSS property cache for efficient style resolution and animation.

//!

//! This module implements a cache layer between the raw CSS stylesheet and the rendered DOM.

//! It resolves CSS properties for each node, handling:

//!

//! - **Cascade resolution**: Computes final values from CSS rules, inline styles, and inheritance

//! - **Pseudo-class states**: Caches styles for `:hover`, `:active`, `:focus`, etc.

//! - **Animation support**: Tracks animating properties for smooth interpolation

//! - **Performance**: Avoids re-parsing and re-resolving unchanged properties

//!

//! # Architecture

//!

//! The cache is organized per-node and per-property-type. Each property has a dedicated

//! getter method that:

//!

//! 1. Checks if the property is cached

//! 2. If not, resolves it from CSS rules + inline styles

//! 3. Caches the result for subsequent frames

//!

//! # Thread Safety

//!

//! Not thread-safe. Each window has its own cache instance.

extern crate alloc;

use alloc::{boxed::Box, string::String, vec::Vec};

use core::fmt::Write;

use core::mem::ManuallyDrop;

use crate::dom::NodeType;

/// Tracks the origin of a CSS property value.

/// Used to correctly implement the CSS cascade and inheritance rules.

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

pub enum CssPropertyOrigin {

    /// Property was inherited from parent node (only for inheritable properties)

    Inherited,

    /// Property is the node's own value (from UA CSS, CSS file, inline style, or user override)

    Own,

}

/// A CSS property with its origin tracking.

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

pub struct CssPropertyWithOrigin {

    pub property: CssProperty,

    pub origin: CssPropertyOrigin,

}

use azul_css::{

    css::{Css, CssPath},

    props::{

        basic::{StyleFontFamily, StyleFontFamilyVec, StyleFontSize},

        layout::{LayoutDisplay, LayoutHeight, LayoutWidth},

        property::{

            BoxDecorationBreakValue, BreakInsideValue, CaretAnimationDurationValue,

            CaretColorValue, CaretWidthValue, ClipPathValue, ColumnCountValue, ColumnFillValue,

            ColumnRuleColorValue, ColumnRuleStyleValue, ColumnRuleWidthValue, ColumnSpanValue,

            ColumnWidthValue, ContentValue, CounterIncrementValue, CounterResetValue, CssProperty,

            CssPropertyType, FlowFromValue, FlowIntoValue, LayoutAlignContentValue,

            LayoutAlignItemsValue, LayoutAlignSelfValue, LayoutBorderBottomWidthValue,

            LayoutBorderLeftWidthValue, LayoutBorderRightWidthValue, LayoutBorderSpacingValue,

            LayoutBorderTopWidthValue, LayoutBoxSizingValue, LayoutClearValue,

            LayoutColumnGapValue, LayoutDisplayValue, LayoutFlexBasisValue,

            LayoutFlexDirectionValue, LayoutFlexGrowValue, LayoutFlexShrinkValue,

            LayoutFlexWrapValue, LayoutFloatValue, LayoutGapValue, LayoutGridAutoColumnsValue,

            LayoutGridAutoFlowValue, LayoutGridAutoRowsValue, LayoutGridColumnValue,

            LayoutGridRowValue, LayoutGridTemplateColumnsValue, LayoutGridTemplateRowsValue,

            LayoutHeightValue, LayoutInsetBottomValue, LayoutJustifyContentValue,

            LayoutJustifyItemsValue, LayoutJustifySelfValue, LayoutLeftValue,

            LayoutMarginBottomValue, LayoutMarginLeftValue, LayoutMarginRightValue,

            LayoutMarginTopValue, LayoutMaxHeightValue, LayoutMaxWidthValue, LayoutMinHeightValue,

            LayoutMinWidthValue, LayoutOverflowValue, LayoutPaddingBottomValue,

            LayoutPaddingLeftValue, LayoutPaddingRightValue, LayoutPaddingTopValue,

            LayoutPositionValue, LayoutRightValue, LayoutRowGapValue, LayoutScrollbarWidthValue,

            LayoutTableLayoutValue, LayoutTextJustifyValue, LayoutTopValue, LayoutWidthValue,

            LayoutWritingModeValue, LayoutZIndexValue, OrphansValue, PageBreakValue,

            StyleBackgroundContentValue, ScrollbarFadeDelayValue, ScrollbarFadeDurationValue,

            ScrollbarVisibilityModeValue, SelectionBackgroundColorValue, SelectionColorValue,

            SelectionRadiusValue, ShapeImageThresholdValue, ShapeInsideValue, ShapeMarginValue,

            ShapeOutsideValue, StringSetValue, StyleBackfaceVisibilityValue,

            StyleBackgroundContentVecValue, StyleBackgroundPositionVecValue,

            StyleBackgroundRepeatVecValue, StyleBackgroundSizeVecValue,

            StyleBorderBottomColorValue, StyleBorderBottomLeftRadiusValue,

            StyleBorderBottomRightRadiusValue, StyleBorderBottomStyleValue,

            StyleBorderCollapseValue, StyleBorderLeftColorValue, StyleBorderLeftStyleValue,

            StyleBorderRightColorValue, StyleBorderRightStyleValue, StyleBorderTopColorValue,

            StyleBorderTopLeftRadiusValue, StyleBorderTopRightRadiusValue,

            StyleBorderTopStyleValue, StyleBoxShadowValue, StyleCaptionSideValue, StyleCursorValue,

            StyleDirectionValue, StyleEmptyCellsValue, StyleExclusionMarginValue,

            StyleFilterVecValue, StyleFontFamilyVecValue, StyleFontSizeValue, StyleFontStyleValue,

            StyleFontValue, StyleFontWeightValue, StyleHangingPunctuationValue,

            StyleHyphenationLanguageValue, StyleHyphensValue, StyleInitialLetterValue,

            StyleLetterSpacingValue, StyleLineBreakValue, StyleLineClampValue, StyleLineHeightValue,

            StyleListStylePositionValue, StyleListStyleTypeValue, StyleMixBlendModeValue,

            StyleAspectRatioValue, StyleObjectFitValue, StyleObjectPositionValue, StyleTextOverflowValue,

            StyleOpacityValue, StylePerspectiveOriginValue,

            StyleScrollbarColorValue, StyleOverflowWrapValue, StyleTabSizeValue,

            StyleTextAlignLastValue, StyleTextOrientationValue, StyleTextTransformValue,

            StyleTextAlignValue, StyleTextColorValue,

            StyleTextCombineUprightValue, StyleUnicodeBidiValue,

            StyleTextBoxTrimValue, StyleTextBoxEdgeValue,

            StyleDominantBaselineValue, StyleAlignmentBaselineValue, StyleBaselineSourceValue,

            StyleLineFitEdgeValue,

            StyleInitialLetterAlignValue, StyleInitialLetterWrapValue,

            StyleScrollbarGutterValue, StyleOverflowClipMarginValue, StyleClipRectValue,

            StyleTextDecorationValue, StyleTextIndentValue,

            StyleTransformOriginValue, StyleTransformVecValue, StyleUserSelectValue,

            StyleVerticalAlignValue, StyleVisibilityValue, StyleWhiteSpaceValue,

            StyleWordBreakValue, StyleWordSpacingValue, WidowsValue,

        },

        style::{StyleCursor, StyleTextColor, StyleTransformOrigin},

    },

    AzString,

};

use crate::{

    dom::{NodeData, NodeId, TabIndex, TagId},

    id::{NodeDataContainer, NodeDataContainerRef},

    style::CascadeInfo,

    styled_dom::{

        NodeHierarchyItem, NodeHierarchyItemId, NodeHierarchyItemVec, ParentWithNodeDepth,

        ParentWithNodeDepthVec, StyledNodeState, TagIdToNodeIdMapping,

    },

};

use azul_css::dynamic_selector::{

    CssPropertyWithConditions, CssPropertyWithConditionsVec, DynamicSelectorContext,

};

#[cfg(feature = "std")]

std::thread_local! {

    static PROP_COUNTS: core::cell::RefCell<

        std::collections::HashMap<&'static str, usize>

    > = core::cell::RefCell::new(std::collections::HashMap::new());

}

/// Drain the per-thread CSS cascade-walk counter populated by

/// [`CssPropertyCache::get_property`] when `AZ_PROP_COUNT=1` is set

/// in the environment.

///

/// Returns `(property_label, count)` pairs

/// sorted by count descending. Layout-side instrumentation calls

/// this after each `layout_document` to print which properties

/// drove the most cascade walks.

#[cfg(feature = "std")]

    // try_with: no real TLS in the lifted-to-wasm web backend (see the

    // get_property recording site) — return empty rather than panic.

// Unit conversion constants (CSS absolute units → pixels)

const PT_TO_PX: f32 = 1.333_333;

const IN_TO_PX: f32 = 96.0;

const CM_TO_PX: f32 = 37.795_277;

const MM_TO_PX: f32 = 3.779_527_7;

/// Match on any `CssProperty` variant and access the inner `CssPropertyValue`<T>.

#[allow(unused_macros)]

macro_rules! match_property_value {

    ($property:expr, $value:ident, $expr:expr) => {

        match $property {

            CssProperty::CaretColor($value) => $expr,

            CssProperty::CaretAnimationDuration($value) => $expr,

            CssProperty::SelectionBackgroundColor($value) => $expr,

            CssProperty::SelectionColor($value) => $expr,

            CssProperty::SelectionRadius($value) => $expr,

            CssProperty::TextColor($value) => $expr,

            CssProperty::FontSize($value) => $expr,

            CssProperty::FontFamily($value) => $expr,

            CssProperty::FontWeight($value) => $expr,

            CssProperty::FontStyle($value) => $expr,

            CssProperty::TextAlign($value) => $expr,

            CssProperty::TextJustify($value) => $expr,

            CssProperty::VerticalAlign($value) => $expr,

            CssProperty::LetterSpacing($value) => $expr,

            CssProperty::TextIndent($value) => $expr,

            CssProperty::InitialLetter($value) => $expr,

            CssProperty::LineClamp($value) => $expr,

            CssProperty::HangingPunctuation($value) => $expr,

            CssProperty::TextCombineUpright($value) => $expr,

            CssProperty::UnicodeBidi($value) => $expr,

            CssProperty::TextBoxTrim($value) => $expr,

            CssProperty::TextBoxEdge($value) => $expr,

            CssProperty::DominantBaseline($value) => $expr,

            CssProperty::AlignmentBaseline($value) => $expr,

            CssProperty::BaselineSource($value) => $expr,

            CssProperty::LineFitEdge($value) => $expr,

            CssProperty::InitialLetterAlign($value) => $expr,

            CssProperty::InitialLetterWrap($value) => $expr,

            CssProperty::ScrollbarGutter($value) => $expr,

            CssProperty::OverflowClipMargin($value) => $expr,

            CssProperty::Clip($value) => $expr,

            CssProperty::ExclusionMargin($value) => $expr,

            CssProperty::HyphenationLanguage($value) => $expr,

            CssProperty::LineHeight($value) => $expr,

            CssProperty::WordSpacing($value) => $expr,

            CssProperty::TabSize($value) => $expr,

            CssProperty::WhiteSpace($value) => $expr,

            CssProperty::Hyphens($value) => $expr,

            CssProperty::Direction($value) => $expr,

            CssProperty::UserSelect($value) => $expr,

            CssProperty::TextDecoration($value) => $expr,

            CssProperty::Cursor($value) => $expr,

            CssProperty::Display($value) => $expr,

            CssProperty::Float($value) => $expr,

            CssProperty::BoxSizing($value) => $expr,

            CssProperty::Width($value) => $expr,

            CssProperty::Height($value) => $expr,

            CssProperty::MinWidth($value) => $expr,

            CssProperty::MinHeight($value) => $expr,

            CssProperty::MaxWidth($value) => $expr,

            CssProperty::MaxHeight($value) => $expr,

            CssProperty::Position($value) => $expr,

            CssProperty::Top($value) => $expr,

            CssProperty::Right($value) => $expr,

            CssProperty::Left($value) => $expr,

            CssProperty::Bottom($value) => $expr,

            CssProperty::ZIndex($value) => $expr,

            CssProperty::FlexWrap($value) => $expr,

            CssProperty::FlexDirection($value) => $expr,

            CssProperty::FlexGrow($value) => $expr,

            CssProperty::FlexShrink($value) => $expr,

            CssProperty::FlexBasis($value) => $expr,

            CssProperty::JustifyContent($value) => $expr,

            CssProperty::AlignItems($value) => $expr,

            CssProperty::AlignContent($value) => $expr,

            CssProperty::AlignSelf($value) => $expr,

            CssProperty::JustifyItems($value) => $expr,

            CssProperty::JustifySelf($value) => $expr,

            CssProperty::BackgroundContent($value) => $expr,

            CssProperty::BackgroundPosition($value) => $expr,

            CssProperty::BackgroundSize($value) => $expr,

            CssProperty::BackgroundRepeat($value) => $expr,

            CssProperty::OverflowX($value) => $expr,

            CssProperty::OverflowY($value) => $expr,

            CssProperty::OverflowBlock($value) => $expr,

            CssProperty::OverflowInline($value) => $expr,

            CssProperty::PaddingTop($value) => $expr,

            CssProperty::PaddingLeft($value) => $expr,

            CssProperty::PaddingRight($value) => $expr,

            CssProperty::PaddingBottom($value) => $expr,

            CssProperty::MarginTop($value) => $expr,

            CssProperty::MarginLeft($value) => $expr,

            CssProperty::MarginRight($value) => $expr,

            CssProperty::MarginBottom($value) => $expr,

            CssProperty::BorderTopLeftRadius($value) => $expr,

            CssProperty::BorderTopRightRadius($value) => $expr,

            CssProperty::BorderBottomLeftRadius($value) => $expr,

            CssProperty::BorderBottomRightRadius($value) => $expr,

            CssProperty::BorderTopColor($value) => $expr,

            CssProperty::BorderRightColor($value) => $expr,

            CssProperty::BorderLeftColor($value) => $expr,

            CssProperty::BorderBottomColor($value) => $expr,

            CssProperty::BorderTopStyle($value) => $expr,

            CssProperty::BorderRightStyle($value) => $expr,

            CssProperty::BorderLeftStyle($value) => $expr,

            CssProperty::BorderBottomStyle($value) => $expr,

            CssProperty::BorderTopWidth($value) => $expr,

            CssProperty::BorderRightWidth($value) => $expr,

            CssProperty::BorderLeftWidth($value) => $expr,

            CssProperty::BorderBottomWidth($value) => $expr,

            CssProperty::BoxShadow($value) => $expr,

            CssProperty::Opacity($value) => $expr,

            CssProperty::Transform($value) => $expr,

            CssProperty::TransformOrigin($value) => $expr,

            CssProperty::PerspectiveOrigin($value) => $expr,

            CssProperty::BackfaceVisibility($value) => $expr,

            CssProperty::MixBlendMode($value) => $expr,

            CssProperty::Filter($value) => $expr,

            CssProperty::Visibility($value) => $expr,

            CssProperty::WritingMode($value) => $expr,

            CssProperty::GridTemplateColumns($value) => $expr,

            CssProperty::GridTemplateRows($value) => $expr,

            CssProperty::GridAutoColumns($value) => $expr,

            CssProperty::GridAutoRows($value) => $expr,

            CssProperty::GridAutoFlow($value) => $expr,

            CssProperty::GridColumn($value) => $expr,

            CssProperty::GridRow($value) => $expr,

            CssProperty::GridTemplateAreas($value) => $expr,

            CssProperty::Gap($value) => $expr,

            CssProperty::ColumnGap($value) => $expr,

            CssProperty::RowGap($value) => $expr,

            CssProperty::Clear($value) => $expr,

            CssProperty::ScrollbarTrack($value) => $expr,

            CssProperty::ScrollbarThumb($value) => $expr,

            CssProperty::ScrollbarButton($value) => $expr,

            CssProperty::ScrollbarCorner($value) => $expr,

            CssProperty::ScrollbarResizer($value) => $expr,

            CssProperty::ScrollbarWidth($value) => $expr,

            CssProperty::ScrollbarColor($value) => $expr,

            CssProperty::ListStyleType($value) => $expr,

            CssProperty::ListStylePosition($value) => $expr,

            CssProperty::Font($value) => $expr,

            CssProperty::ColumnCount($value) => $expr,

            CssProperty::ColumnWidth($value) => $expr,

            CssProperty::ColumnSpan($value) => $expr,

            CssProperty::ColumnFill($value) => $expr,

            CssProperty::ColumnRuleStyle($value) => $expr,

            CssProperty::ColumnRuleWidth($value) => $expr,

            CssProperty::ColumnRuleColor($value) => $expr,

            CssProperty::FlowInto($value) => $expr,

            CssProperty::FlowFrom($value) => $expr,

            CssProperty::ShapeOutside($value) => $expr,

            CssProperty::ShapeInside($value) => $expr,

            CssProperty::ShapeImageThreshold($value) => $expr,

            CssProperty::ShapeMargin($value) => $expr,

            CssProperty::ClipPath($value) => $expr,

            CssProperty::Content($value) => $expr,

            CssProperty::CounterIncrement($value) => $expr,

            CssProperty::CounterReset($value) => $expr,

            CssProperty::StringSet($value) => $expr,

            CssProperty::Orphans($value) => $expr,

            CssProperty::Widows($value) => $expr,

            CssProperty::PageBreakBefore($value) => $expr,

            CssProperty::PageBreakAfter($value) => $expr,

            CssProperty::PageBreakInside($value) => $expr,

            CssProperty::BreakInside($value) => $expr,

            CssProperty::BoxDecorationBreak($value) => $expr,

            CssProperty::TableLayout($value) => $expr,

            CssProperty::BorderCollapse($value) => $expr,

            CssProperty::BorderSpacing($value) => $expr,

            CssProperty::CaptionSide($value) => $expr,

            CssProperty::EmptyCells($value) => $expr,

        }

    };

}

/// A CSS property tagged with its pseudo-state and property type.

///

/// Replaces the per-pseudo-state `BTreeMap` approach: instead of 6 `BTreeMaps`

/// per node (Normal/Hover/Active/Focus/Dragging/DragOver), we store one Vec

/// per node and tag each property with its state. Lookups use `.iter().find()`.

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

pub struct StatefulCssProperty {

    pub state: azul_css::dynamic_selector::PseudoStateType,

    pub prop_type: CssPropertyType,

    pub property: CssProperty,

}

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

// FlatVecVec: Cache-friendly replacement for Vec<Vec<T>>

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

/// A flat, cache-friendly replacement for `Vec<Vec<T>>`.

///

/// During the **build phase**, items are pushed into per-node inner Vecs

/// (same as before). After building is complete, `flatten()` compacts all

/// inner Vecs into a single contiguous `Vec<T>` with a `(start, len)` offset

/// table per node. All subsequent reads use the flat layout, eliminating

/// N heap allocations and pointer chasing.

///

/// ## Lifecycle

///

/// ```text

/// new(n) → push_to(idx, item)* → sort_each_and_flatten(key_fn) → get_slice(idx)*

///          ── build phase ──       ── transition ──                ── read phase ──

/// ```

#[derive(Debug, Clone)]

pub struct FlatVecVec<T> {

    /// Per-node inner Vecs (used during build phase, empty after flatten).

    build: Vec<Vec<T>>,

    /// Flat contiguous storage (populated after flatten).

    data: Vec<T>,

    /// `(start, len)` offsets into `data` for each node (populated after flatten).

    offsets: Vec<(u32, u32)>,

}

impl<T: PartialEq> PartialEq for FlatVecVec<T> {

        );

        } else {

        }

}

impl<T> Default for FlatVecVec<T> {

}

impl<T> FlatVecVec<T> {

    /// Approximate heap bytes retained. Sums capacity of the

    /// flattened `data` + `offsets` tables and the per-node build

    /// Vecs (in case `sort_each_and_flatten` hasn't been called

    /// yet). `per_element_size` should be `size_of::<T>()`.

    /// Create a new `FlatVecVec` with `node_count` empty slots (build phase).

    /// Push an item to the inner Vec at `node_index` (build phase).

    ///

    /// # Panics

    /// Panics if already flattened or if `node_index >= len()`.

    #[inline]

    /// Get a mutable reference to the inner Vec at `node_index` (build phase).

    #[inline]

    /// Iterate mutably over all inner Vecs (build phase, e.g. for clearing).

    #[inline]

    /// Get a reference to the inner Vec at `node_index` during build phase.

    /// During read phase, returns None (use `get_slice` instead).

    #[inline]

    /// Number of node slots.

    #[inline]

        } else {

        }

    /// Returns `true` if there are no node slots.

    #[inline]

    /// Returns true if this is in read (flattened) mode.

    #[inline]

    /// Get a slice for the node at `node_index` (read phase).

    /// Returns empty slice if index is out of bounds or not yet flattened

    /// (falls back to build-phase data if not yet flattened).

    #[inline]

            // Build phase fallback: use inner Vecs

        } else {

            // Read phase: use flat data

            } else {

            }

        }

    /// Flatten: sort each inner Vec by key, deduplicate by keeping the last

    /// occurrence of each key (CSS cascade: later source order wins among

    /// equal specificity), then compact into flat storage.

    /// Drains all build-phase Vecs. After this call, only `get_slice()` works.

            // Deduplicate: keep last of each consecutive-key group (CSS cascade).

            }

            // Drain inner and push only kept items

            }

        }

    /// Flatten without sorting (for data that's already sorted).

    /// Rebuild flat storage, keeping only items matching `predicate`.

    /// Must be called after flatten. Preserves per-node ordering.

            }

        }

    /// Return to build phase from read (flattened) phase, preserving all data, so

    /// `push_to` / `build_mut` work again. No-op if already in build phase.

    ///

    /// The build → flatten → read progression is otherwise one-way, but `restyle()`

    /// legitimately runs more than once on the same cache (`StyledDom::create` does one

    /// internal pass, then the public API may do more), and building the compact cache

    /// flattens these vecs in between. Without re-entering build phase, the next

    /// restyle's `push_to` / `build_mut` would index an emptied `build` and panic.

    /// Like `retain`, but passes each item's owning node index to the predicate.

    /// Must be called after flatten. Preserves per-node ordering.

            }

        }

    /// Iterate over all nodes, yielding (`node_index`, &[T]) for each.

    /// Works in both build and flattened phases.

    /// Extend this `FlatVecVec` with all nodes from `other` (append for DOM merge).

    /// Both must be in build phase, or both must be flattened.

            // Both flattened: extend flat data with offset adjustment

}

/// Iterator over (`node_index`, &[T]) pairs from a `FlatVecVec`.

pub(crate) struct FlatVecVecIter<'a, T> {

    fvv: &'a FlatVecVec<T>,

    idx: usize,

    count: usize,

}

impl<'a, T> Iterator for FlatVecVecIter<'a, T> {

    type Item = (usize, &'a [T]);

    #[inline]

}

impl<T> ExactSizeIterator for FlatVecVecIter<'_, T> {}

// NOTE: To avoid large memory allocations, this is a "cache" that stores all the CSS properties

// found in the DOM. This cache exists on a per-DOM basis, so it scales independent of how many

// nodes are in the DOM.

//

// If each node would carry its own CSS properties, that would unnecessarily consume memory

// because most nodes use the default properties or override only one or two properties.

//

// The cache can compute the property of any node at any given time, given the current node

// state (hover, active, focused, normal). This way we don't have to duplicate the CSS properties

// onto every single node and exchange them when the style changes. Two caches can be appended

// to each other by simply merging their NodeIds.

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

pub struct CssPropertyCache {

    // number of nodes in the current DOM

    pub node_count: usize,

    // The author stylesheet this cache was last cascaded with. Retained so nodes

    // inserted at runtime can be re-styled (`StyledDom::restyle_retained`) — the

    // cascade runs once at creation, and without the rules an inserted node could

    // only ever receive UA defaults + inheritance, never its author CSS.

    // (This struct lives behind `CssPropertyCachePtr`, so the field is invisible

    // to the C ABI.)

    pub retained_author_css: Css,

    // properties that were overridden in callbacks (not specific to any node state)

    pub user_overridden_properties: Vec<Vec<(CssPropertyType, CssProperty)>>,

    /// The window's dynamic-selector context (viewport size, theme, OS,

    /// media type...), provided by the layout funnel before the first

    /// layout. `None` = context UNKNOWN (a freshly created `StyledDom` that no

    /// window has adopted yet): non-pseudo-state conditions then evaluate to

    /// "does not apply", which is the same behaviour they always had before

    /// contexts were wired through. Pseudo-state conditions never depend on

    /// this field.

    pub dynamic_context: Option<Box<DynamicSelectorContext>>,

    // non-default CSS properties that were cascaded from the parent,

    // unified across all pseudo-states (Normal, Hover, Active, Focus, Dragging, DragOver).

    // Stored in a flat cache-friendly layout after sort_and_flatten().

    pub cascaded_props: FlatVecVec<StatefulCssProperty>,

    // non-default CSS properties that were set via a CSS file,

    // unified across all pseudo-states.

    pub css_props: FlatVecVec<StatefulCssProperty>,

    // Pre-resolved inherited properties (sorted Vec per node, keyed by CssPropertyType)

    pub computed_values: Vec<Vec<(CssPropertyType, CssPropertyWithOrigin)>>,

    // Compact layout cache: three-tier numeric encoding for O(1) layout lookups.

    // Built once after restyle + apply_ua_css + compute_inherited_values.

    // Non-compact properties (background, shadow, transform) use get_property_slow().

    pub compact_cache: Option<azul_css::compact_cache::CompactLayoutCache>,

    // Global CSS properties from `*` rules — shared across all nodes.

    // Applied during build_compact_cache_with_inheritance instead of being

    // cloned into each node's css_props (saves 50K×N clones).

    pub global_css_props: Vec<CssProperty>,

    /// Per-node resolved font-size, in pixels, for the `Normal`

    /// pseudo-state. Populated lazily on first call to

    /// [`crate::styled_dom::StyledDom::resolved_font_size_px`] via a

    /// single bottom-up DOM walk; subsequent reads are O(1) Vec

    /// index by `NodeId::index()`.

    ///

    /// Motivation: `get_font_size` is called ~730× per node per

    /// layout pass (see `AZ_PROP_COUNT=1` report — 329 629

    /// cascade walks on excel.html alone). Each resolution

    /// recursively reads the parent's font-size (for `em`) plus

    /// the root's font-size (for `rem`), multiplying the walk

    /// count. Caching the pre-resolved pixel value collapses that

    /// to a single `Vec<f32>` indexed lookup.

    pub resolved_font_sizes_px: crate::sync::OnceLock<Vec<f32>>,

}

/// Heap-size breakdown of a `CssPropertyCache`, produced by

/// [`CssPropertyCache::memory_breakdown`]. All values in bytes.

///

/// Primarily a diagnostic — the numbers are capacity-based and

/// don't chase into property-variant payloads (e.g. the `Vec`

/// inside a `FontFamily(...)`). Intended for "which subfield is

/// eating RSS" triage, not for precise accounting.

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

pub struct CssPropertyCacheBreakdown {

    pub node_count: usize,

    pub cascaded_props_bytes: usize,

    pub css_props_bytes: usize,

    pub computed_values_bytes: usize,

    pub user_overridden_bytes: usize,

    pub global_css_props_bytes: usize,

    pub compact_cache_bytes: usize,

    pub resolved_font_sizes_bytes: usize,

}

impl CssPropertyCacheBreakdown {

    /// Sum of all subfields.

}

impl CssPropertyCache {

    /// Approximate heap bytes retained by this cache, broken out by

    /// subfield. Used by `StyledDom::memory_breakdown` + the

    /// `AZ_PROFILE=memory` reporter. Sums capacity × element size

    /// for each Vec and adds a coarse allowance for the inner Vec

    /// headers inside `computed_values`.

    ///

    /// This is a measurement helper, not a tight bound — it doesn't

    /// chase into the `CssProperty` enum variants that carry their

    /// own `Vec`/`String` allocations (notably `FontFamily` →

    /// `StyleFontFamilyVec` → `Vec<StyleFontFamily>`), so the real

    /// heap footprint for a property-rich DOM can be 2-3× these

    /// numbers. Still useful for spotting gross duplication between

    /// the pre-compact and compact caches.

        };

    /// Drop Normal-state properties that have compact encodings from

    /// `css_props` and `cascaded_props`. After `build_compact_cache_with_inheritance`,

    /// these are redundant — the compact cache is the source of truth for layout.

    /// Non-Normal entries (hover/active/focus) and non-compact properties

    /// (background, box-shadow, transform, etc.) are kept for `get_property_slow`.

        use azul_css::dynamic_selector::PseudoStateType;

        #[cfg(feature = "std")]

        {

        static PRUNE_DBG: std::sync::OnceLock<bool> = std::sync::OnceLock::new();

                }

            }

                }

            }

        }

        // The compact cache stores SENTINEL for pixel-valued properties whose inner

        // value is Exact with a non-px metric (vh, vw, %, em, rem, calc(), ...).

        // Those need the slow `css_props` walk at layout time because the compact

        // cache has nothing usable. We must keep them here or the slow path falls

        // back to UA CSS and silently clobbers the author's rule.

            // Compact-encoded AND Normal: drop only if the compact cache fully

            // captured the value (px metric, or Auto/Initial/Inherit/None).

        // DO NOT prune css_props: regenerate_layout calls

        // recompute_inheritance_and_compact_cache() every frame, which REBUILDS the

        // compact cache from css_props (build_compact_cache_with_inheritance reads

        // css_props in its per-node Step 3). If we drop compact-encoded Normal props

        // here, that rebuild reads pruned css_props and resets those props to their

        // CSS-initial value — e.g. white-space:pre-wrap on a node regressed to Normal

        // on the 2nd (recompute) build, collapsing \n in pre-wrap text into one line

        // (#8, intermittently — depends on whether the recompute ran). The doc's

        // premise ("the compact cache is the source of truth", implying permanence)

        // is false given that per-frame recompute. cascaded_props is NOT read by the

        // rebuild (Step 1 inherits from the parent's COMPACT value, not cascaded_props),

        // so pruning it remains safe. TODO: re-enable css_props pruning once recompute

        // becomes incremental (preserve directly-set compact values instead of rebuilding).

    /// Look up a CSS property for a specific pseudo-state in a stateful property vec.

    /// Requires the vec to be sorted by (state, `prop_type`).

    #[inline]

    // prop_cache threads &NodeId/&CssPropertyType uniformly through its hot cascade

    // lookup API (40+ such params); flipping only clippy's few flags to by-value

    // would force ref/deref juggling at every boundary with the by-ref majority,

    // for no measurable hot-path gain — keep the uniform by-ref convention.

    #[allow(clippy::trivially_copy_pass_by_ref)]

    /// Check if any properties exist for a specific pseudo-state in a stateful property vec.

    /// Requires the vec to be sorted by (state, `prop_type`).

    #[inline]

        // All entries with the same state are contiguous. Use partition_point

        // to find the first entry >= state, then check if it matches.

    /// Collect all property types for a specific pseudo-state.

}

/// Returns true if `prop`'s value cannot be fully represented in the compact

/// cache and therefore needs to survive `prune_compact_normal_props` so the

/// slow `css_props` walk can still find it at layout time.

///

/// Pixel-valued properties (margin, padding, width, height, ...) are the only

/// case: `Exact(pv)` with `pv.metric != Px` (vh, vw, %, em, rem, ...) encodes

/// to the compact cache's SENTINEL slot, which loses the value. All other

/// compact-encoded types (tier1 enums, colors, hashes, etc.) always round-trip

/// through the compact encoding.

    use azul_css::css::CssPropertyValue;

    use azul_css::props::{

        basic::length::SizeMetric,

        layout::{

            dimensions::{LayoutHeight, LayoutWidth},

            flex::LayoutFlexBasis,

        },

    };

    // `inner: PixelValue` wrapper types — check metric directly.

    macro_rules! check_plain {

        ($v:expr) => {{

            if let CssPropertyValue::Exact(ref inner) = $v {

                return inner.inner.metric != SizeMetric::Px;

            }

            false

        }};

    }

        // LayoutWidth / LayoutHeight: enum with `Px(PixelValue)` variant.

        // Non-pixel variants (Auto / MinContent / MaxContent / FitContent / Calc)

        // are already handled by the tier1 fast path or don't exist as i16 dims.

        }

        }

        // LayoutFlexBasis: enum with `Exact(PixelValue)` variant.

        }

        // `inner: PixelValue` wrappers

        // All other compact-encoded types round-trip through the compact cache.

    }

/// Clone a `CssProperty` WITHOUT going through its derived `Clone`. The derived clone

/// is a ~179-arm `match self { V(x) => V(x.clone()) }` that LLVM lowers to an indirect

/// HALFWORD jump table (`ldrh`-indexed). The web (remill→wasm) backend mis-lifts that

/// table, so for HEAP/Vec-bearing variants (gradients, font-family, shadows, filters,

/// transforms) the mis-dispatched clone reads wrong-sized data and the cascade traps

/// with "memory access out of bounds" (restyle → inherit → clone). Here every

/// heap-bearing variant is dispatched via single-variant `if let` — a direct

/// discriminant compare, NO jump table — and each inner `v.clone()` is the value

/// type's own clone, which lifts correctly. POD variants fall through to the derived

/// clone: correct on native, and harmless on web (a mis-dispatched discriminant 0 is

/// `CaretColor`, a `Copy` value with no heap pointer to deref). On native this function

/// is byte-for-byte equivalent to `p.clone()`.

/// Inheritable properties whose value must be inherited as the parent's already

/// *resolved* value, NOT propagated as a raw declaration through `cascaded_props`.

///

/// `font-size` is the case: a relative parent value (`1.5em`) propagated raw

/// would be re-resolved against the already-resolved parent at every descendant

/// (multiplicative error: 30px -> 45px -> 67.5px down a chain), and a parent

/// whose own `cascaded` font-size is the *grandparent's* absolute value would

/// skip the parent's own size entirely. Both consuming paths already inherit

/// font-size correctly from the parent's resolved value — `inherit_from_parent`

/// for `computed_values`, and the parent's resolved compact slot in

/// `build_compact_cache_with_inheritance` — so font-size must not ride the raw

/// propagation at all.

    use azul_css::props::property::CssProperty;

impl CssPropertyCache {

    /// Match CSS selectors to nodes and populate `css_props`.

    /// Returns tag IDs for hit-testing. If `compact_cache` is available,

    /// uses it for fast display/overflow checks; otherwise falls back to slow path.

    #[must_use]

    #[allow(clippy::too_many_lines, clippy::cognitive_complexity)] // large but cohesive: single-purpose parser/builder/dispatch (one branch per input variant)

        use azul_css::{

            css::{CssDeclaration, CssPathPseudoSelector::{Hover, Active, Focus, Dragging, DragOver}, CssPathSelector, CssRuleBlock},

            dynamic_selector::{DynamicSelector, PseudoStateType},

            props::layout::LayoutDisplay,

        };

        // @-rule conditions (@media width/height, theme, OS...) gate whole

        // rule BLOCKS. Evaluated here against the window's dynamic context —

        // rules whose conditions do not hold are dropped from this cascade

        // exactly as if absent, and `StyledDom::set_dynamic_selector_context`

        // re-runs the cascade when the context changes and the author css

        // has conditional rules. With NO context yet (a StyledDom no window

        // has adopted), conditional rules do not apply — the same behaviour

        // inline conditional properties have always had. (Until 2026-08-10

        // these conditions were silently IGNORED: an author

        // `@media (max-width: 720px)` block applied at every viewport.)

            // Separate CSS rules into "global only" (just `*`) vs "has specific selector".

            // Global-only rules apply to ALL nodes — push directly into css_props

            // without per-node selector matching (avoids m×n for these rules).

            // Specific rules still go through matches_html_element per-node.

            }

            // Re-enter build phase before repopulating. restyle() is not

            // single-shot: StyledDom::create runs one restyle internally, and building

            // the compact cache flattens these vecs — so on a later restyle both are in

            // read phase, where the old reset `build_iter_mut().clear()` silently

            // iterated ZERO entries (flatten empties `build`). The push_to / build_mut

            // below then indexed an emptied Vec and panicked.

            //

            // css_props is rebuilt from scratch each restyle (repopulated below,

            // flattened at the end), so replace it with a fresh build-phase vec.

            //

            // cascaded_props is rebuilt from scratch TOO (2026-08-12): the old

            // preserve-and-or_insert approach LEAKED properties of rules whose

            // @-condition turned OFF — a color inherited under a min-width

            // block survived in every descendant after crossing below it, so

            // wide and narrow styling applied SIMULTANEOUSLY (the

            // media_restyle_cost law pin caught it). Preservation is

            // unnecessary: the inheritance walk is top-down (parents' fresh

            // slices are written before children read them — the same

            // ordering css_props relies on), so a fresh build-phase vec

            // repopulates completely. The historical reason for preserving

            // was a phase-bug in the old clear, not a data dependency.

            // Collect global-only rule declarations ONCE (not per-node).

            // These are stored in self.global_css_props and applied during

            // build_compact_cache_with_inheritance for each node, avoiding

            // 50K × N clones into per-node css_props Vecs.

                    }

            }

            // Phase 2: Match specific rules per-node (only non-global rules)

            // Per-node "which declarations match" lists are built as

            // `(rule_idx, decl_idx)` pairs — 4 bytes per entry instead of

            // cloning a 140-byte `CssProperty`. The clone only happens at

            // the final push_to step, so the transient peak is ~35× smaller.

            //

            // rule_idx indexes into `specific_rules` (Vec<&CssRuleBlock>),

            // decl_idx indexes into `rule.declarations.as_slice()`. Both

            // fit in u16 since real stylesheets have far fewer than 65k

            // rules and declarations per rule.

            macro_rules! filter_rules {($expected_pseudo_selector:expr, $node_id:expr) => {{

                let mut out: Vec<(u16, u16)> = Vec::new();

                for (rule_idx, rule_block) in specific_rules.iter().enumerate() {

                    if !rule_applies(&rule_block.conditions) {

                        continue;

                    }

                    if !crate::style::rule_ends_with(&rule_block.path, $expected_pseudo_selector) {

                        continue;

                    }

                    if !crate::style::matches_html_element(

                        &rule_block.path,

                        $node_id,

                        &node_hierarchy.as_container(),

                        &node_data,

                        &html_tree,

                        $expected_pseudo_selector,

                    ) {

                        continue;

                    }

                    for (decl_idx, decl) in rule_block.declarations.as_slice().iter().enumerate() {

                        if matches!(decl, CssDeclaration::Static(_)) {

                            out.push((u16::try_from(rule_idx).unwrap_or(u16::MAX), u16::try_from(decl_idx).unwrap_or(u16::MAX)));

                        }

                    }

                }

                out

            }};}

            // Pre-check which pseudo-states have any matching rules at all.

            // This avoids iterating 50K nodes for pseudo-states with zero rules

            // (common: most stylesheets have no :hover/:focus/:active rules).

            macro_rules! collect_and_assign {

                ($pseudo:expr, $state:expr, $has_any:expr) => {

                    if $has_any {

                        let indices: NodeDataContainer<(NodeId, Vec<(u16, u16)>)> = node_data

                        for (n, pairs) in indices.internal.into_iter() {

                            for (rule_idx, decl_idx) in pairs {

                                let decl = &specific_rules[rule_idx as usize]

                                    .declarations

                                    .as_slice()[decl_idx as usize];

                                if let CssDeclaration::Static(prop) = decl {

                                    self.css_props.push_to(n.index(), StatefulCssProperty {

                                        state: $state,

                                        prop_type: prop.get_type(),

                                        property: prop.clone(),

                                    });

                                }

                            }

                        }

                    }

                };

            }

        // Inheritance: Inherit all values of the parent to the children, but

        // only if the property is inheritable and isn't yet set

            };