//! 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::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)]

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,

            StyleOpacityValue, StylePerspectiveOriginValue,

            StyleScrollbarColorValue, StyleOverflowWrapValue, StyleTabSizeValue,

            StyleTextAlignLastValue, StyleTextOrientationValue,

            StyleTextAlignValue, StyleTextColorValue,

            StyleTextCombineUprightValue, StyleUnicodeBidiValue,

            StyleTextBoxTrimValue, StyleTextBoxEdgeValue,

            StyleDominantBaselineValue, StyleAlignmentBaselineValue,

            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.333333;

const IN_TO_PX: f32 = 96.0;

const CM_TO_PX: f32 = 37.7952755906;

const MM_TO_PX: f32 = 3.7795275591;

/// 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::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)]

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

            // Read phase: use flat data

            } else {

            }

        } else {

            // Build phase fallback: use inner Vecs

        }

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

            }

        }

    /// 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<'a, T> ExactSizeIterator for FlatVecVecIter<'a, 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,

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

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

    // 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_MEM_BREAKDOWN=1` 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();

                }

            }

                }

            }

                normal_compact, normal_noncompact, nonnormal, ssp_sz, casc_total, casc_normal_compact);

        }

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

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

    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]

        use azul_css::{

            css::{CssDeclaration, CssPathPseudoSelector::*},

            props::layout::LayoutDisplay,

        };

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

            use azul_css::css::{CssPathSelector, CssRuleBlock};

            }

            // Clear all css_props before assigning

            use azul_css::dynamic_selector::PseudoStateType;

            // 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 !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((rule_idx as u16, decl_idx as u16));

                        }

                    }

                }

                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

            };

            use azul_css::dynamic_selector::{DynamicSelector, PseudoStateType};

                // 1. Inherit inline CSS properties from parent for this pseudo-state

                        } else {

                        }

                // 2. Inherit CSS stylesheet properties from parent for this pseudo-state

                } else {

                };

                // 3. Inherit cascaded properties from parent for this pseudo-state

                // Combine all inheritable props (inline first = strongest, cascaded last)

                // Only insert if child doesn't already have that (state, prop_type) combo

                {

                    {

                        // or_insert: only insert if child doesn't already have this (state, prop_type)

                    }

                }

            }

        }

        // Sort css_props by (state, prop_type) for binary search lookups,

        // then flatten into contiguous memory for cache-friendly reads.

    /// Generate hit-test tag IDs for nodes that need event handling.

    /// Uses compact cache (if available) for fast display/overflow reads.

    /// Can be called separately after build_compact_cache_with_inheritance.

        // Tag ID generation: determine which nodes need hit-test tags for

        // hover/click/scroll events. Uses compact cache for display/overflow

        // checks instead of get_property_slow (which searches 6 data structures).

        use azul_css::compact_cache::{

            DISPLAY_SHIFT, DISPLAY_MASK,

            OVERFLOW_X_SHIFT, OVERFLOW_Y_SHIFT, OVERFLOW_MASK,

        };