// +spec:box-model:b3a79e - box assigned same styles as generating element; getters read from styled DOM per node

//! Centralized CSS property getters for the layout solver pipeline

use azul_core::{

    dom::{NodeId, NodeType},

    geom::LogicalSize,

    id::NodeId as CoreNodeId,

    styled_dom::{StyledDom, StyledNodeState},

};

use azul_css::{

    css::CssPropertyValue,

    props::{

        basic::{

            font::{StyleFontFamily, StyleFontFamilyVec, StyleFontStyle, StyleFontWeight},

            pixel::{DEFAULT_FONT_SIZE, PT_TO_PX},

            time::CssDuration,

            ColorU, PhysicalSize, PixelValue, PropertyContext, ResolutionContext,

        },

        layout::{

            grid::GridTemplateAreas, BoxDecorationBreak, BreakInside, LayoutAlignContent,

            LayoutAlignItems, LayoutBoxSizing, LayoutClear, LayoutDisplay, LayoutFlexDirection,

            LayoutFlexWrap, LayoutFloat, LayoutHeight, LayoutJustifyContent, LayoutOverflow,

            LayoutPosition, LayoutWidth, LayoutWritingMode, Orphans, PageBreak,

            StyleOverflowClipMargin, StyleScrollbarGutter, Widows,

        },

        property::{

            CssProperty, CssPropertyType, LayoutAlignContentValue, LayoutAlignItemsValue,

            LayoutAlignSelfValue, LayoutFlexBasisValue, LayoutFlexDirectionValue,

            LayoutFlexGrowValue, LayoutFlexShrinkValue, LayoutFlexWrapValue, LayoutGapValue,

            LayoutGridAutoColumnsValue, LayoutGridAutoFlowValue, LayoutGridAutoRowsValue,

            LayoutGridColumnValue, LayoutGridRowValue, LayoutGridTemplateColumnsValue,

            LayoutGridTemplateRowsValue, LayoutJustifyContentValue, LayoutJustifyItemsValue,

            LayoutJustifySelfValue,

        },

        style::{

            border_radius::StyleBorderRadius,

            lists::{StyleListStylePosition, StyleListStyleType},

            StyleAlignmentBaseline, StyleBaselineSource, StyleDirection, StyleDominantBaseline,

            StyleInitialLetterAlign, StyleLineFitEdge,

            StyleInitialLetterWrap, StyleTextAlign, StyleTextBoxEdge, StyleTextBoxTrim,

            StyleUnicodeBidi, StyleUserSelect, StyleVerticalAlign, StyleVisibility,

            StyleWhiteSpace,

        },

    },

};

use crate::{

    font_traits::{ParsedFontTrait, StyleProperties},

    solver3::{

        display_list::{BorderRadius, PhysicalSizeImport},

        layout_tree::LayoutNode,

        scrollbar::ScrollbarRequirements,

    },

};

const DEFAULT_EM_SIZE: f32 = 16.0;

const DEFAULT_CARET_WIDTH_PX: f32 = 2.0;

// ONE authority for the default blink period: the manager's constant.

// This and CURSOR_BLINK_INTERVAL_MS disagreeing (500 vs 530) is what made

// the "which default wins" question unanswerable — do not fork it again.

#[allow(clippy::cast_possible_truncation)]

const DEFAULT_CARET_BLINK_MS: u32 = crate::managers::text_edit::CURSOR_BLINK_INTERVAL_MS as u32;

const DEFAULT_TAB_SIZE: f32 = 8.0;

const SCROLLBAR_WIDTH_THIN: f32 = 8.0;

const SCROLLBAR_WIDTH_AUTO: f32 = 12.0;

const SCROLLBAR_HOVER_EXPAND_PX: f32 = 4.0;

const THUMB_HOVER_LIGHTEN: u8 = 30;

const THUMB_HOVER_ALPHA_ADD: u8 = 40;

const THUMB_ACTIVE_DARKEN: u8 = 15;

// Font-size resolution helper functions

/// Helper function to get element's computed font-size.

///

/// **Memoised** for the common `Normal` pseudo-state: the first

/// call on a given `StyledDom` populates

/// `css_property_cache.ptr.resolved_font_sizes_px` via a single

/// bottom-up DOM walk (N cascade walks total, stored as

/// `Vec<f32>`); every subsequent call is a single Vec index.

/// Non-normal state falls through to [`resolve_font_size_slow`].

///

/// Motivation: `AZ_PROP_COUNT=1` measured 329 629 `font-size`

/// cascade walks per cold layout on excel.html (~730 per node).

/// With this cache that collapses to ~500 total (one per node,

/// once), and subsequent layouts hit the Vec directly.

///

/// The semantics of the slow path are preserved exactly: the

/// `compute_all_font_sizes_px` walker mirrors the original's

/// `computed_values` → cascade → `DEFAULT_FONT_SIZE` ordering,

/// so rendered pixels are byte-identical.

    // M12.7 FIX: the OnceLock-cached fast path

    // (`is_normal → resolved_font_sizes_px.get_or_init(|| compute_all_font_sizes_px) →

    // sizes.get`) MIS-LIFTS to wasm — it diverges (create_node_from_dom never returns →

    // empty LayoutTree → 0 rects). PROVEN by isolation: skipping it lets

    // get_element_font_size reach + return via resolve_font_size_slow, and

    // create_resolution_context completes (sub-step 1→4). resolve_font_size_slow is the

    // same resolution unmemoized (correct), so we always use it. (Native desktop is

    // unaffected in correctness; it loses the per-DOM memoization — a minor perf cost

    // only on the lifted web path's small DOMs. The cache-block lift bug — likely the

    // compute_all_font_sizes_px closure's control/FP — is documented for a later remill

    // fix that can restore the fast path.)

/// Bottom-up single-pass resolve of every node's font-size.

/// Parents are computed before children (DFS pre-order invariant

/// on `NodeId::index()`), so `em` inherits via the parent's

/// already-stored pixel value. `rem` reads from `sizes[0]` once

/// the root is populated (the root's own size resolves via the

/// `computed_values` short-circuit if set, otherwise DEFAULT).

///

/// Preserves the original resolution order exactly:

///

/// 1. `computed_values` binary search → if `FontSize` is pre-

///    resolved to a px value, use that.

/// 2. Full cascade via `cache.get_font_size(...)`; if an explicit

///    value is present, resolve with context.

/// 3. `DEFAULT_FONT_SIZE` fallback — NOT `parent_font_size`,

///    because the `computed_values` short-circuit at step 1 is

///    the cascade's inheritance channel (pre-populated for every

///    inheriting node).

    use azul_css::props::{

        basic::length::SizeMetric,

        property::{CssProperty, CssPropertyType},

    };

        // Step 1: computed_values short-circuit (matches original).

        // Step 2: full cascade walk.

        };

        };

        // Step 2.5: compact cache fast path — avoids a full cascade walk

        // per node. The build-time pass has already resolved em/% to px,

        // so the raw u32 here is the final pixel value when set.

                    // Already-resolved pixel value (em/% eliminated during build).

        // Step 3: fallback to DEFAULT (matches original .unwrap_or).

    }

/// Un-memoised recursive resolution, used as the fallback for

/// non-normal pseudo-states in [`get_element_font_size`] and

/// directly by tests that bypass the StyledDom-scoped cache.

/// Keeps the original semantics verbatim.

    // ITERATIVE resolution (was unbounded self-recursion up the parent chain, which

    // stack-overflowed on deeply nested DOMs and was O(N*depth)). We walk `parent_id`

    // in a loop to collect the ancestor chain, then resolve top-down so each node's

    // `em` inherits from its already-resolved parent. Result is identical to the old

    // recursive version for a well-formed tree, but bounded by the tree depth in

    // stack usage (a single Vec of ancestors instead of nested frames).

    //

    // Each ancestor is resolved against its OWN `styled_node_state` (previously the

    // recursion incorrectly threaded the *child's* state into parent/root resolution),

    // matching the sibling `get_parent_font_size` / `get_root_font_size` helpers.

    // Root font-size, resolved from NodeId(0) with no parent and root == DEFAULT

    // (mirrors the original: for node 0 the root branch returned DEFAULT directly).

    } else {

            DEFAULT_FONT_SIZE,

            DEFAULT_FONT_SIZE,

        )

    };

    // Collect the ancestor chain: chain[0] == dom_id, chain.last() == topmost ancestor.

    // Resolve top-down. The topmost ancestor has parent_font_size == DEFAULT; each

    // subsequent node inherits the previously-resolved value as its parent size.

        // The target node keeps the caller-provided state (its own state, per the

        // public contract); ancestors use their own stored state.

        } else {

        };

        } else {

        };

    }

/// Resolves a single node's font-size given its already-resolved `parent_font_size`

/// and `root_font_size`. Contains the per-node logic that the old recursive

/// `resolve_font_size_slow` applied at each frame (computed-values px short-circuit,

/// then a full cascade walk), with no recursion of its own.

/// Helper function to get parent's computed font-size.

///

/// Retrieves the parent's own `StyledNodeState` so that pseudo-class-specific

/// font-size rules (e.g. `div:hover { font-size: 32px }`) are resolved

/// against the parent's actual state, not the child's.

/// Helper function to get root element's font-size.

///

/// Uses the root element's own `StyledNodeState` so that pseudo-class-specific

/// rules are resolved correctly regardless of which node triggered the call.

/// A value that can be Auto, Initial, Inherit, or an explicit value.

/// This preserves CSS cascade semantics better than Option<T>.

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

#[derive(Default)]

pub enum MultiValue<T> {

    /// CSS 'auto' keyword

    #[default]

    Auto,

    /// CSS 'initial' keyword - use initial value

    Initial,

    /// CSS 'inherit' keyword - inherit from parent

    Inherit,

    /// Explicit value (e.g., "10px", "50%")

    Exact(T),

}

impl<T> MultiValue<T> {

    /// Returns true if this is an Auto value

    /// Returns true if this is an explicit value

    /// Gets the exact value if present

        }

    /// Gets the exact value or returns the provided default

        }

    /// Gets the exact value or returns `T::default()`

    {

        }

    /// Maps the inner value if Exact, otherwise returns self unchanged

    {

        }

}

// Implement helper methods for LayoutOverflow specifically

impl MultiValue<LayoutOverflow> {

    /// Returns true if this overflow value causes content to be clipped.

    /// This includes Hidden, Clip, Auto, and Scroll (all values except Visible).

        )

        )

    // +spec:overflow:3be57c - overflow:hidden disables user scrolling but programmatic scrolling still works

    /// Does this value establish a SCROLL CONTAINER (css-overflow-3 §3.1)?

    /// `hidden | scroll | auto` — an `overflow: hidden` box is

    /// programmatically scrollable even though its user scrolling is

    /// disabled. The unset sentinel (initial = visible) does not.

        )

    /// Does this value allow scrolling DIRECTLY TRIGGERED BY THE USER

    /// (wheel, scrollbar, keyboard)? `hidden` does not.

        )

        )

        )

    /// True iff `overflow` is EXPLICITLY set to a value that establishes a block

    /// formatting context (CSS 2.2 §9.4.1: `hidden`/`scroll`/`auto`). `visible`,

    /// `clip`, and the unset/initial/inherit sentinel do NOT — the initial value

    /// is `visible`, so an unset overflow must not establish a BFC. Using

    /// `!is_visible_or_clip()` for this was wrong: the "not set" `MultiValue::Auto`

    /// sentinel is not visible/clip, so every plain block spuriously got a BFC on

    /// the slow cascade path (the fast path returns `Exact(Visible)` and did not).

        )

    // +spec:overflow:833078 - visible/clip compute to auto/hidden if other axis is scrollable

    /// Resolves the computed value per CSS Overflow 3 § 3.1:

    /// visible/clip values compute to auto/hidden (respectively)

    /// if the other axis is neither visible nor clip.

    ///

    /// The UNSET sentinel means the initial value `visible`, and the rule

    /// applies to it the same way: an unset axis computes to `auto` when the

    /// other axis is scrollable. The old catch-all left it unresolved, so on

    /// the slow path (pseudo-states / no compact cache) callers treated the

    /// axis as visible instead of a scroll container - the compact fast path

    /// (which always materializes `Exact`) disagreed.

        };

        };

        // Keep the sentinel when nothing changed (an unset axis stays unset

        // unless the rule upgrades it), so downstream unset-vs-explicit

        // distinctions (BFC establishment) are preserved.

        }

}

// Implement helper methods for LayoutPosition

impl MultiValue<LayoutPosition> {

        )

}

// Implement helper methods for LayoutFloat

impl MultiValue<LayoutFloat> {

        )

}

/// Helper macro to reduce boilerplate for simple CSS property getters

/// Returns the inner `PixelValue` wrapped in `MultiValue`

macro_rules! get_css_property_pixel {

    // Variant WITH compact cache fast path for i16-encoded resolved px properties

    ($fn_name:ident, $cache_method:ident, $ua_property:expr, compact_i16 = $compact_method:ident) => {

            // FAST PATH: compact cache for normal state (O(1) array lookup)

                        // Valid value: decode i16 ×10 → px

                    // I16_SENTINEL or I16_INHERIT → fall through to slow path

    };

}

/// Helper trait to extract `PixelValue` from any `CssProperty` variant

trait CssPropertyPixelInner {

    fn get_pixel_inner(&self) -> Option<PixelValue>;

}

impl CssPropertyPixelInner for CssProperty {

        }

}

/// Generic macro for CSS properties with UA CSS fallback - returns `MultiValue`<T>

macro_rules! get_css_property {

    // Variant WITH compact cache fast path (for enum properties in Tier 1)

    ($fn_name:ident, $cache_method:ident, $return_type:ty, $ua_property:expr, compact = $compact_method:ident) => {

            // FAST PATH: compact cache for normal state (O(1) array + bitshift)

            // NOTE (M12.7): skipping this fast path does NOT fix get_display_type's

            // divergence — the slow path / the `match get_display_type(...)` on the

            // LayoutDisplay enum (a niche-discriminant) mis-lifts too. So this isn't the

            // cache (unlike the font-size fix); it's the deeper niche/enum decode. Kept.

            // SLOW PATH: full cascade resolution

            // 1. Check author CSS first

            // 2. Check User Agent CSS

            // 3. Fallback to Auto (not set)

    };

    // Variant WITH compact cache for u32-encoded dimension enums (LayoutWidth/LayoutHeight)

    // These types have Auto, Px(PixelValue), MinContent, MaxContent, Calc variants

    ($fn_name:ident, $cache_method:ident, $return_type:ty, $ua_property:expr, compact_u32_dim = $compact_raw_method:ident, $px_variant:path, $auto_variant:path, $min_content_variant:path, $max_content_variant:path) => {

            // FAST PATH: compact cache for normal state

                        _ => {

                            // Valid encoded pixel value

                            // decode failed → slow path

                        }

                    }

            // SLOW PATH: full cascade resolution

    };

    // Variant WITH compact cache for u32-encoded dimension structs (LayoutMinWidth etc.)

    // These types are struct { inner: PixelValue }

    ($fn_name:ident, $cache_method:ident, $return_type:ty, $ua_property:expr, compact_u32_struct = $compact_raw_method:ident) => {

            // FAST PATH: compact cache for normal state

                        _ => {

                        }

                    }

            // SLOW PATH

    };

    // Variant WITHOUT compact cache (original behavior)

    ($fn_name:ident, $cache_method:ident, $return_type:ty, $ua_property:expr) => {

            // 1. Check author CSS first

            // 2. Check User Agent CSS

            // 3. Fallback to Auto (not set)

    };

}

/// Helper trait to extract typed values from UA CSS properties

trait ExtractPropertyValue<T> {

    fn extract(&self) -> Option<T>;

}

{

// Implement extraction for all layout types

impl ExtractPropertyValue<LayoutWidth> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutHeight> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutMinWidth> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutMinHeight> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutMaxWidth> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutMaxHeight> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutDisplay> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutWritingMode> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutFlexWrap> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutJustifyContent> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleTextAlign> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutFloat> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutClear> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutOverflow> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutPosition> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutBoxSizing> for CssProperty {

        }

}

impl ExtractPropertyValue<PixelValue> for CssProperty {

}

impl ExtractPropertyValue<LayoutFlexDirection> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutAlignItems> for CssProperty {

        }

}

impl ExtractPropertyValue<LayoutAlignContent> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleFontWeight> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleFontStyle> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleVisibility> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleWhiteSpace> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleDirection> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleUnicodeBidi> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleTextBoxTrim> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleTextBoxEdge> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleDominantBaseline> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleAlignmentBaseline> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleBaselineSource> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleLineFitEdge> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleInitialLetterAlign> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleInitialLetterWrap> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleScrollbarGutter> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleOverflowClipMargin> for CssProperty {

        }

}

impl ExtractPropertyValue<StyleVerticalAlign> for CssProperty {

        }

}

get_css_property!(

    get_writing_mode,

    get_writing_mode,

    LayoutWritingMode,

    CssPropertyType::WritingMode,

    compact = get_writing_mode

);

get_css_property!(

    get_css_width,

    get_width,

    LayoutWidth,

    CssPropertyType::Width,

    compact_u32_dim = get_width_raw,

    LayoutWidth::Px,

    LayoutWidth::Auto,

    LayoutWidth::MinContent,

    LayoutWidth::MaxContent

);

get_css_property!(

    get_css_height,

    get_height,

    LayoutHeight,

    CssPropertyType::Height,

    compact_u32_dim = get_height_raw,

    LayoutHeight::Px,

    LayoutHeight::Auto,

    LayoutHeight::MinContent,

    LayoutHeight::MaxContent

);

get_css_property!(

    get_wrap,

    get_flex_wrap,

    LayoutFlexWrap,

    CssPropertyType::FlexWrap,

    compact = get_flex_wrap

);

get_css_property!(

    get_justify_content,

    get_justify_content,

    LayoutJustifyContent,

    CssPropertyType::JustifyContent,

    compact = get_justify_content

);

get_css_property!(

    get_text_align,

    get_text_align,

    StyleTextAlign,

    CssPropertyType::TextAlign,

    compact = get_text_align

);

get_css_property!(

    get_float,

    get_float,

    LayoutFloat,

    CssPropertyType::Float,

    compact = get_float

);

get_css_property!(

    get_clear,

    get_clear,

    LayoutClear,

    CssPropertyType::Clear,

    compact = get_clear

);

get_css_property!(

    get_overflow_x_declared,

    get_overflow_x,

    LayoutOverflow,

    CssPropertyType::OverflowX,

    compact = get_overflow_x

);

get_css_property!(

    get_overflow_y_declared,

    get_overflow_y,

    LayoutOverflow,

    CssPropertyType::OverflowY,

    compact = get_overflow_y

);

// +spec:overflow:17654b - overflow-block and overflow-inline logical properties resolve to physical overflow based on writing mode

/// Physical `overflow-x`, with the css-overflow-3 logical fallback: when the

/// physical property is unset, a declared `overflow-inline` (horizontal

/// writing modes) or `overflow-block` (vertical) supplies the value. On the

/// compact fast path the mapping already happened at build time, in

/// declaration order (equal-specificity last-wins); this slow-path fallback

/// uses "physical if declared, else logical" as the cascade approximation.

        MultiValue::Exact(LayoutWritingMode::VerticalRl | LayoutWritingMode::VerticalLr)

    );