//! Intrinsic and used size calculations for layout nodes

use std::{

    collections::BTreeSet,

    sync::Arc,

};

use azul_core::{

    dom::{FormattingContext, NodeId, NodeType},

    geom::LogicalSize,

    resources::RendererResources,

    styled_dom::{StyledDom, StyledNodeState},

};

use azul_css::{

    css::CssPropertyValue,

    props::{

        basic::PixelValue,

        layout::{LayoutDisplay, LayoutFlexDirection, LayoutFlexWrap, LayoutFloat, LayoutHeight, LayoutPosition, LayoutWidth, LayoutWritingMode},

        property::{CssProperty, CssPropertyType},

    },

    LayoutDebugMessage,

};

use rust_fontconfig::FcFontCache;

#[cfg(feature = "text_layout")]

use crate::text3;

use crate::{

    font::parsed::ParsedFont,

    font_traits::{

        AvailableSpace, FontLoaderTrait, FontManager, ImageSource, InlineContent, InlineImage,

        InlineShape, LayoutCache, LayoutFragment, ObjectFit, ParsedFontTrait, ShapeDefinition,

        StyleProperties, UnifiedConstraints,

    },

    solver3::{

        fc::split_text_for_whitespace,

        geometry::{BoxProps, BoxSizing, IntrinsicSizes, WritingModeContext},

        getters::{

            get_css_box_sizing, get_css_height, get_css_width, get_display_property,

            get_direction_property, get_element_font_size, get_flex_direction, get_float,

            get_style_properties, get_text_orientation_property, get_writing_mode, MultiValue,

        },

        layout_tree::{LayoutNodeHot, LayoutTree, get_display_type},

        positioning::get_position_type,

        LayoutContext, LayoutError, Result,

    },

};

/// Resolves a percentage value against the containing block dimension.

///

/// Per CSS 2.1 Section 10.2, percentages resolve directly against the containing

/// block's width or height. The margin/border/padding parameters are accepted for

/// call-site convenience but are intentionally unused — percentage resolution does

/// not subtract box-model extras in content-box sizing.

///

/// Returns `(containing_block_dimension * percentage).max(0.0)`.

// +spec:containing-block:43c719 - percentages resolved against containing block width/height

// +spec:containing-block:723eee - Percentages specify sizing with respect to the containing block

// +spec:containing-block:8ad6f4 - Percentage resolution against containing block (editorial note: transferred percentages)

// +spec:containing-block:257f3b - Block-axis percentages resolve against containing block size

// +spec:containing-block:f1344e - percentage min/max-width resolved against containing block width; negative CB width yields zero

    // +spec:containing-block:b3388b - percentage resolved against containing block size without re-resolution (css-sizing-3 §5.2.1)

    // CSS 2.1 Section 10.2: percentages resolve against containing block,

    // not available space after margins/borders/padding

/// Returns true if the DOM subtree rooted at `dom_id` contains any `NodeType::Text`.

///

/// Used when deciding whether a `FormattingContext::Inline` node should measure

/// its inline content (it acts as an IFC root when nested inlines eventually

/// hold text) versus returning zero (pure inline wrapper with no text reaches).

/// Phase 2a: Calculate intrinsic sizes (bottom-up pass)

/// // +spec:display-contents:f12d4e - intrinsic sizing: size determined by contents, not context

// [g71 TEST] #[inline(never)] — RELIABLE bisection (g70, markers in free band) showed new_tree drops

// 2→0 RIGHT BEFORE this call. It's currently INLINED into layout_document (absent from the lift log),

// so its frame/entry isn't a separate SP-wrapped @sub_ call. Forcing it OUT makes the call a wrapped

// @sub_ → enforce_sp_preservation save/restores SP around it. If new_tree survives (sizingEntry=2),

// the inlined entry/frame-setup was mis-lifting SP. (g60's inline(always) was a no-op — already inlined.)

#[inline(never)]

    // [az-diag g59 REVERT] RELIABLE field-access bracket (pointer CASTS mis-lift to 0 — g58 proved

    // it; use tree.nodes.len() which is reliable). 0x407B0 = nodes.len at ENTRY. If 2 here but

    // 0x40734 (line ~142, after compute_dirty_ancestor_closure + calculator) reads 0, the corruption

    // is in 121-142. compute_dirty_ancestor_closure RETURNS a HashSet by sret — prime suspect:

    // sret-slot overlapping new_tree, or the hashbrown empty-map bug. 0x407B4 (post-compute_dirty)

    // isolates compute_dirty vs calculator-creation.

    // Pre-compute the "ancestor closure" of dirty_nodes: every dirty

    // node AND each of its ancestors up to root. A node not in this

    // set (and whose `intrinsic_sizes` is already populated) can

    // reuse its cached intrinsic — we skip its entire subtree walk.

    // Before this, `calculate_intrinsic_recursive` walked the full

    // tree from root regardless, costing ~2 ms per warm render on

    // excel.html even when only 3 nodes were actually dirty.

    // [az-diag g59 REVERT] 0x407B4 = nodes.len AFTER compute_dirty_ancestor_closure (its HashSet sret).

    // Fix C (re-enabled §58 Win #3): skip intrinsic computation for subtrees

    // whose values will never be consumed. `tree.subtree_needs_intrinsic` is a

    // static-DOM bitmap precomputed at tree-build time — true if this node or

    // any descendant establishes a shrink-to-fit context. When both the

    // caller and the subtree are non-STF, no one reads the intrinsic, so the

    // whole descent is pure waste.

    //

    // The previous attempt (7667d13e, reverted in bd9ad36d) wrote default

    // (zero) intrinsics and broke auto-height rendering because

    // calculate_used_size_for_node read intrinsic.max_content_height as the

    // height:auto fallback. 97c3d3db refactored that dependency away: for

    // block-level auto-height, used_size.height is 0 pre-layout and

    // apply_content_based_height fills it from the laid-out content size.

    // With that gone, skipping intrinsic is safe.

    // [az-diag g53 REVERT] DECISIVE: is the lifted LayoutTree itself empty/broken? If

    // tree.get(root)=None (0x40738=0) or nodes.len()=0 (0x40734), the InvalidTree@229 is

    // because RECONCILE produced a broken tree — root cause is reconcile, not sizing.

        }

    }

struct IntrinsicSizeCalculator<'a, 'b, 'c, T: ParsedFontTrait> {

    ctx: &'a mut LayoutContext<'b, T>,

    /// Shared text shaping cache, threaded through from the caller so

    /// stages 1–3 of the inline layout pipeline (logical / BiDi / shaping)

    /// are cache-hits across the sizing pass's min/max-content measurements

    /// AND the subsequent real layout pass. Previously each pass held its

    /// own `LayoutCache`, so identical text was shaped three times per

    /// root_layout_pass — once per min-content measurement, once per

    /// max-content measurement, once at final layout.

    text_cache: &'c mut LayoutCache,

    /// If `Some`, only nodes in this set (the ancestor-closure of

    /// dirty nodes) need recomputation. A clean node whose

    /// `warm.intrinsic_sizes` is already populated reuses the

    /// cached value and skips its entire subtree descent.

    dirty_closure: Option<std::collections::HashSet<usize>>,

}

impl<'a, 'b, 'c, T: ParsedFontTrait> IntrinsicSizeCalculator<'a, 'b, 'c, T> {

        // [az-diag g52 REVERT] 0x40720 = node_index entering calculate_intrinsic_recursive

        // (last value after the run = the node that InvalidTree'd or the stray child).

        // Fast path: if this subtree has no dirty nodes AND we

        // already have a cached intrinsic, return the cached value

        // and skip the whole descent. Caller is the ancestor-closure

        // computation in `calculate_intrinsic_sizes` — anything not

        // in that set is guaranteed clean through every descendant.

                {

        // Fix C static-DOM short-circuit: if no ancestor needs this intrinsic

        // (none are STF) AND no descendant in this subtree is STF, nobody

        // will ever read the value. Write a default and skip the recursion.

        // `subtree_needs_intrinsic` is precomputed at tree-build time from

        // the DOM's display/position/float properties, so this is a constant

        // lookup with no per-pass work.

        {

        // Previously cloned the full LayoutNode to sidestep borrow conflicts

        // with the `&mut tree` recursive calls below, but we only need the

        // DOM id here — a `Copy` scalar. The clone was allocating a

        // Vec<usize> for children and a TaffyCache on every recursion

        // (~300x on excel.html).

            .dom_node_id;

        // Out-of-flow elements do not contribute to their parent's intrinsic size.

        // Copy child indices before recursive calls (which need &mut tree).

        // Stack buffer for the common case (≤32 children); heap only for huge nodes.

        let heap_buf: Vec<usize>;

        } else {

        };

        // Propagate STF flag: children inherit `ancestor_is_stf=true` if any

        // ancestor up to and including self is STF.

                )

            // [az-diag g52 REVERT] 0x40728 = child_index about to recurse (last = the stray).

            // [g52 FIX] Defensive: reconcile can mis-list a stray/out-of-range child_index

            // (a Text node mis-listed as a layout child, or a lift artifact in the children

            // array). The unguarded recursion would hit `tree.get(child_index).ok_or(InvalidTree)`

            // at line ~226 and abort the WHOLE intrinsic-sizing pass. Skip gracefully so

            // measurement continues — mirrors process_layout_children's guard (line ~1079).

            // REAL fix = reconcile not listing the stray child.

        }

        // Then calculate this node's intrinsic size based on its children

        // +spec:min-max-sizing:970fef - if min-width/min-height is a <length>, use as floor for intrinsic sizes

            use azul_css::props::basic::{pixel::{DEFAULT_FONT_SIZE, PT_TO_PX}, SizeMetric};

            use crate::solver3::getters::{get_css_min_width, get_css_min_height, MultiValue};

                };

                };

        // +spec:block-formatting-context:30def2 - replaced elements use physical 300x150 default, not re-oriented by writing-mode

        // +spec:display-property:015c41 - replaced elements default to 300x150 intrinsic size per css-sizing-3 §5.1

        // +spec:display-property:2c6af3 - replaced elements with auto width/height use max-content size

        // +spec:replaced-elements:6d6030 - Intrinsic sizes for replaced elements (images, virtual views)

        // VirtualViews are replaced elements with a default intrinsic size of 300x150px

        // (same as virtualized view elements)

            // +spec:containing-block:bb5a12 - replaced element intrinsic sizes using initial containing block

            // +spec:display-property:7127f9 - intrinsic sizes of replaced elements without natural sizes (300x150 fallback, aspect ratio)

            // +spec:display-property:f9cede - replaced elements derive intrinsic size from natural dimensions

            // +spec:writing-modes:b18121 - stretch fit inline size from available space, calculate block size via aspect ratio

                // +spec:containing-block:1da6dc - use initial CB inline size for replaced elements with aspect ratio but no intrinsic size

                // Per css-sizing-3 §5.1: "use an inline size matching the corresponding dimension

                // of the initial containing block and calculate the other dimension using the aspect ratio"

                    // Has intrinsic height but no width — use initial CB inline dimension

                } else {

                    // +spec:replaced-elements:43376b - 300px fallback with 2:1 ratio for replaced elements

                    // No intrinsic dimensions — cap at 300x150 per CSS 2.2 §10.3.2

                    // +spec:width-calculation:3b0efe - auto width fallback: 300px capped to device width

                    // +spec:width-calculation:16c305 - auto height fallback: 2:1 ratio, max 150px

                };

                // A replaced element with NO intrinsic size (e.g. a RenderImageCallback

                // <img> like the AzulPaint canvas) must behave like a VirtualView: keep

                // the 300×150 fallback as the min/max-content (so it has a sensible

                // default) but leave `preferred` as None so `flex-grow` / explicit CSS

                // can size it. A `Some(preferred)` here pins the box and defeats

                // flex-grow (the canvas was laid out 300×0 — see the VirtualView arm

                // above, which already uses None for exactly this reason). Images WITH

                // a real intrinsic size keep `preferred = Some` so they display at their

                // natural size when unconstrained.

                } else {

                };

            FormattingContext::Block { .. } => {

                // Check if this block establishes an Inline Formatting Context (IFC).

                // Per CSS 2.2 §9.2.1.1: A block container with mixed block-level and

                // inline-level children creates anonymous block boxes to wrap the inline

                // content. So we only treat as IFC root if there are NO block-level children.

                //

                // We check the actual CSS display property, NOT formatting_context,

                // because a display:block element with only inline children gets

                // FormattingContext::Inline (meaning "establishes IFC for its children"),

                // which is different from being an inline element itself.

                            // Text nodes are inline-level

                                LayoutDisplay::Inline

                                | LayoutDisplay::InlineBlock

                                | LayoutDisplay::InlineFlex

                                | LayoutDisplay::InlineGrid

                                | LayoutDisplay::InlineTable

                            )

                // IFC root only if there are inline children and NO block children.

                // If there are block children, text nodes get anonymous block wrappers.

                // Also check if this block has direct text content (text nodes in DOM)

                // but ONLY if there are no block-level layout children

                    } else {

                    }

                } else {

                };

                    // This block is an IFC root - measure all inline content ONCE

                } else {

                    // This is a BFC root (only block children) - aggregate child sizes

                }

            }

            FormattingContext::Inline => {

                // There are THREE cases for FormattingContext::Inline:

                // 1. A Text node (NodeType::Text) - this IS the text content itself

                //    -> Needs to measure itself as an atomic inline unit

                // 2. An IFC root - a block with only inline children (has text child nodes)

                //    -> Should measure its inline content

                // 3. A true inline element (display: inline, e.g., <span>) with no text

                //    -> Returns default(0,0), measured by parent IFC root

                //

                // We distinguish by:

                // - Checking if THIS node is a Text node (case 1)

                // - Checking if this subtree contains any text (case 2)

                //

                // Why descendants, not just direct children: for `<span><a>text</a></span>`,

                // the `<span>` is a layout-tree IFC root (layout_ifc is called on it), but

                // its direct DOM children are inline elements, not text. Restricting the

                // check to direct text children would zero out the span's intrinsic width

                // even though the cell content width depends on it.

                } else {

                };

                } else {

                };

                    // Case 1 or 2: Text node or IFC root - measure inline content

                } else {

                    // Case 3: True inline element - measured by parent IFC root

                }

            }

            FormattingContext::InlineBlock => {

                // Inline-block IS an atomic inline - it needs its own intrinsic size.

                // Check layout tree children AND direct DOM text children (text nodes

                // are not in the layout tree, only in the DOM).

                } else {

                };

                    // InlineBlock with inline children - measure as IFC root.

                    // Returns content-level intrinsic sizes (no margin/padding/border).

                    // The parent adds box-model extras via calculate_block_intrinsic_sizes,

                    // and calculate_used_size_for_node adds padding+border for border-box.

                } else {

                    // InlineBlock with block children - aggregate like block

                }

            }

            FormattingContext::Table => {

            }

            FormattingContext::Flex => {

            }

        }

    // +spec:intrinsic-sizing:ea2c2c - §5.1 min-content size = size as float with auto; max-content = no wrapping

    /// Calculate intrinsic sizes for an IFC root (a block containing inline content).

    /// This collects ALL inline descendants' text and measures it ONCE.

    // +spec:intrinsic-sizing:8f3c0c - hanging glyphs must be excluded from intrinsic size measurement

        // [g75] 0x60758 = how many times this IFC sizer is entered; 0x6075C = node_index of THIS call.

        // Collect all inline content from this IFC root and its inline descendants

        // [g76] EXPLICIT match (was `?`): the g75 markers showed collect_inline_content reaching its

        // completion marker B8 (Ok at the source level) yet the IFC sizer never advancing to 0xA1 —

        // i.e. the lifted `Result<Vec<InlineContent>, LayoutError>` return arrives as Err at this call

        // site (a complex by-value Result-return mis-lift). 0x60760 = 1 (Ok) / 0xEE (Err-but-B8-ran).

        // RESILIENCE: on Err, degrade to empty content (→ default intrinsic) instead of aborting the

        // WHOLE layout with InvalidTree, so the page renders and the next real blocker surfaces.

        // g76 PROVED: degrading to Vec::new() here (resilience) lets layout proceed past this

        // InvalidTree but then HANGS in the downstream actual-layout shaping (the documented g47

        // hashbrown empty-map infinite loop). So for a CLEAN (non-hanging) state we PROPAGATE the Err

        // (same as the original `?`), keeping the 0x60760 diagnostic. To chase the g47 hang, flip the

        // Err arm back to `Vec::new()`. 0x60760 = 1 (Ok) / 0xEE (Err-despite-B8 = the Result mis-lift).

        // [g78] OUT-PARAM refactor: the by-value `Result<Vec<InlineContent>, LayoutError>` return

        // mis-lifted Ok→Err (g76/g77 PROVED it: 0x60760=0xEE despite the source reaching B8). Filling

        // a `&mut Vec` out-param and returning `Result<()>` (register-returned, NO sret-of-Vec) lifts

        // cleanly — the established M12.7 "a pointer arg lifts cleanly" pattern. 0x60760 should now =1.

        #[cfg(feature = "web_lift")]

        unsafe { crate::az_mark((0x60760) as u32, (if collect_result.is_ok() { 0x00000001u32 } else { 0x000000EEu32 }) as u32); }

        // Get pre-loaded fonts from font manager

        // +spec:intrinsic-sizing:ae8beb - min-content = zero-width CB, max-content = infinite-width CB

        // +spec:intrinsic-sizing:8c94e2 - min-content/max-content intrinsic size determination via constrained layout

        // Use `measure_intrinsic_widths` instead of two `layout_flow` passes (fix B):

        // it runs stages 1–4 of the pipeline once (logical → BiDi → shape → orient)

        // and derives min/max-content by scanning the shaped items directly. This

        // avoids the BreakCursor line-breaking loop entirely — that loop clones

        // every ShapedCluster it inspects via `peek_next_unit` and accounted for

        // 24% of total CPU on the text_2000 stress fixture. Shaping is cached

        // at the per-item level (keyed on text+style), so the subsequent real

        // layout_flow call for this content gets pure cache hits for stages 1–3.

        // [g79 DIAG] Probe the font state at shaping time, then convert the downstream shape_text

        // HANG (g47 hashbrown empty-map loop) → trap so the harness RETURNS and these markers are

        // readable (can't read markers from a hung wasm call). Tests the #4→#3 coupling: if

        // 0x60768(font_chain_cache.len) / 0x6076C(loaded_fonts.len) are 0, the EMPTY FONT CHAIN is

        // the ROOT of the hang (no font → allsorts builds empty hashbrown maps → RawIter loops).

        // [g82] CONDITIONAL trap: if the font_chain_cache is still EMPTY, shaping would HANG (allsorts

        // builds empty hashbrown maps → g47 RawIter loop) → trap instead so the markers are readable

        // (non-hang). If the chain is NON-empty (unique_font_keys BTreeMap fix worked + populated it),

        // PROCEED into measure → shape → text should MEASURE. g81 hung (no conditional) → need to know

        // whether the chain populated. 0x60768=chain.len, 0x6076C=loaded_fonts.len, 0x60704=0xA15.

        #[cfg(feature = "web_lift")]

        {

            let cl = self.ctx.font_manager.font_chain_cache.len();

            unsafe {

                crate::az_mark((0x60768) as u32, (cl as u32) as u32);

                crate::az_mark((0x6076C) as u32, (loaded_fonts.len() as u32) as u32);

                crate::az_mark((0x60704) as u32, (0xA15u32) as u32);

            }

            // [g88] g85+g87 PROVED whack-a-mole does NOT converge: BTreeMap'd unique_font_keys (chain

            // ✓), supported_features+lookups_index (g85), ReadCache (g87) — STILL HANGS. Too many

            // hashbrown empty-map sites across allsorts/std/rust-fontconfig. The ONLY convergent fix is

            // the SYSTEMIC transpiler empty-static mirror (force the lifted hashbrown ctrl-scan to read

            // 0xFF not 0x00). TEMP non-hang trap until that lands. ★ REMOVE to test the systemic fix.

            // [g93] PROCEED into shaping to test the AZ_FORCE_MIRROR_VMADDRS hashbrown-EMPTY_GROUP fix.

            // If text MEASURES → the forced const pages contained EMPTY_GROUP → systemic fix found.

            let _ = (cl, loaded_fonts.len());

        }

            Err(_) => {

            }

        };

        // +spec:display-property:c587fd - min-content block size equals max-content block size for block containers, tables, inline boxes

        // +spec:intrinsic-sizing:02eedc - min-content block size equals max-content block size for block containers

        // For a single-line max-content layout the height is one line box;

        // `measure_intrinsic_widths` returns exactly that.

        // NOTE(writing-modes): min_content_width / max_content_width are named for

        // the physical axis. In vertical writing modes the "inline" axis is vertical,

        // so these are swapped by calculate_block_intrinsic_sizes when computing

        // the parent's intrinsic sizes. The physical naming is intentional here.

    // +spec:containing-block:bb0658 - percentage block-sizes behave as auto during intrinsic computation (no CSS height resolution here)

    // +spec:display-contents:84fe7f - cyclic percentage contributions: percentage-sized children use auto during intrinsic sizing

    // +spec:min-max-sizing:411904 - percentage block-sizes treated as auto during intrinsic sizing (content-sized CB)

    // +spec:min-max-sizing:737e62 - percentage heights don't resolve inside content-sized containing blocks

        } else {

        };

        // NOTE: Text content detection is now handled in calculate_node_intrinsic_sizes

        // which calls calculate_ifc_root_intrinsic_sizes for blocks with inline content.

        // This function now only handles pure block containers (BFC roots).

        // +spec:height-calculation:d9ca8d - cyclic percentage contributions: percentage min-height/max-height on children should behave as auto when computing intrinsic contributions (not yet implemented)

        // Track margins for CSS 2.2 §8.3.1 collapsing in the block direction.

        // Block margins collapse between siblings (max instead of sum) and

        // parent-child margins can escape (first/last child).

                // +spec:intrinsic-sizing:ed72bb - intrinsic contributions based on outer size, auto margins as zero

                        }

                    } else {

                    };

                };

                // CSS 2.2 §8.3.1 margin collapsing for intrinsic sizing:

                // - First child's margin-start can escape (don't add to total)

                // - Between siblings: collapsed gap = max(prev_end, curr_start)

                // - Last child's margin-end can escape (don't add to total)

        }

        // Last child's margin-end may escape — don't add it to total_main_size

        };

    // The max-content main size is the sum of items' max-content contributions.

    // The min-content main size of a single-line flex container is the sum of items'

    // min-content contributions. For multi-line, it is the largest min-content contribution.

    // Auto margins on flex items are treated as 0 for this computation.

        // Determine flex-direction to know if main axis is horizontal or vertical

            }

        } else {

        };

                } else {

                };

                // For multi-line min-content, track the largest single item

                // Cross axis: largest child determines the container's cross size

        }

        // For single-line (nowrap), min-content = sum; for multi-line (wrap), min-content = max

        // Default flex-wrap is nowrap (single-line)

            );

                    LayoutFlexWrap::NoWrap

                ),

            }

        } else {

        };

        } else {

        }

    /// Calculate intrinsic sizes for a table element by aggregating cell content

    /// widths per column and row heights.

    /// +spec:table-layout:93b13c - shrink-to-fit for tables uses intrinsic sizing

        // Collect per-column min/max widths and total row heights.

        // Table structure: table > row-group? > row > cell

        // Iterate rows — children may be row groups (thead/tbody/tfoot) or direct rows

                FormattingContext::TableRowGroup => {

                    // Row group contains rows

                    }

                }

            }

        }

                // Also check if cell has IFC content we can measure

                } else {

                    // Try to measure cell content via IFC

                };

                // Add cell box-model extras

            }

        }

}

/// Gathers all inline content for the intrinsic sizing pass.

///

/// This function recursively collects text and inline-level content according to

/// CSS Sizing Level 3, Section 4.1: "Intrinsic Sizes"

/// https://www.w3.org/TR/css-sizing-3/#intrinsic-sizes

///

/// For inline formatting contexts, we need to gather:

/// 1. Text nodes (inline content)

/// 2. Inline-level boxes (display: inline, inline-block, etc.)

/// 3. Atomic inline-level elements (replaced elements like images)

///

/// The key difference from `collect_and_measure_inline_content` in fc.rs is that

/// this version is used for intrinsic sizing (calculating min/max-content widths)

/// before the actual layout pass, so it must recursively gather content from

/// inline descendants without laying them out first.

    // [g78] fill the caller's out-param (was a local Vec returned by value → Ok→Err mis-lift).

    // Recursively collect inline content from this node and its inline descendants

    // [g73] B8 = top-level recursion returned Ok (collect_inline_content complete).

/// Recursive helper for collecting inline content.

///

/// According to CSS Sizing Level 3, the intrinsic size of an inline formatting context

/// is based on all inline-level content, including text in nested inline elements.

///

/// This function:

/// - Collects text from the current node if it's a text node

/// - Collects text from DOM children (text nodes may not be in layout tree)

/// - Recursively collects from inline children (display: inline)

/// - Treats non-inline children as atomic inline-level boxes

    // [g75] capture node_index of EVERY recursion entry (0x60754) and mark the entry-tree.get

    // FAILURE distinctly (inline-phase=0xBAD) so a node_index that fails HERE (before B1) is

    // visible even though a PRIOR successful call already wrote B8. This is the suspected

    // InvalidTree site (phase stuck at 0xA0 + B8 reached ⇒ a 2nd IFC call fails at this get).

        None => {

        }

    };

    // CRITICAL FIX: Text nodes may exist in the DOM but not as separate layout nodes!

    // We need to check the DOM children for text content.

        // No DOM ID means this is a synthetic node, skip text extraction

    };

    // First check if THIS node is a text node

    // CRITICAL: Also check DOM children for text nodes!

    // Text nodes are often not represented as separate layout nodes.

    // However, we must SKIP children that already have a layout tree entry,

    // because those will be handled by process_layout_children() below.

    // Without this guard, text nodes present in both DOM and layout tree

    // get collected twice, causing inline-block containers to be ~2x too wide.

        // Skip DOM children that have layout tree nodes - they will be

        // processed via process_layout_children -> collect_inline_content_recursive

        // Check if this DOM child is a text node

    }

    // [g73] B6 = DOM-children loop done (about to process_layout_children).

/// Helper to process layout tree children for inline content collection

    use azul_css::props::basic::SizeMetric;

    use azul_css::props::layout::{LayoutHeight, LayoutWidth};

    // [g73] PLC entry: 0x60708 = 0xC0<<24 | node_index (which node's children we process).

    // Process layout tree children (these are elements with layout properties)

        // [g73] PLC loop: 0x6070C = current child_index being processed.

        // 2026-06-02: was `.ok_or(LayoutError::InvalidTree)?` — a stray/invalid child_index in

        // tree.children (likely a Text node mis-listed during reconcile, since Text is INLINE

        // content not a layout-tree node) aborted the WHOLE intrinsic-sizing pass with

        // InvalidTree BEFORE the inline text got measured → label height 0. Skip gracefully so

        // measurement continues (the inline text is collected separately above, at the

        // collect_inline_content_recursive DOM-children loop). REAL fix = reconcile not listing it.

        };

        // CSS Sizing Level 3: Inline-level boxes participate in the IFC

            // Recursively collect content from inline children

            // This is CRITICAL for proper intrinsic width calculation!

        } else {

            // Non-inline children are treated as atomic inline-level boxes

            // (e.g., inline-block, images, floats)

            // Their intrinsic size must have been calculated in the bottom-up pass

            // CSS 2.2 § 10.3.9: For inline-block elements with explicit CSS width/height,

            // use the CSS-defined values instead of intrinsic sizes.

            // Resolve CSS width - use explicit value if set, otherwise fall back to intrinsic

                    // Convert PixelValue to f32

                    use azul_css::props::basic::pixel::{DEFAULT_FONT_SIZE, PT_TO_PX};

                        // +spec:containing-block:495930 - percentages in intrinsic sizing fall back to intrinsic contribution (css-sizing-3 §5.2.1)

                        // For percentages and viewport units, fall back to intrinsic

                        // +spec:containing-block:5246c0 - cyclic percentage: when containing block size depends on this box's intrinsic contribution, percentages fall back to intrinsic size

                        // +spec:containing-block:598124 - cyclic percentage contributions use intrinsic size

                        // +spec:height-calculation:ca9f19 - percentage-sized boxes use intrinsic size as contribution during intrinsic sizing

                        // +spec:width-calculation:7a384a - percentage-sized boxes behave as width:auto for intrinsic contributions (cyclic percentage)

                    }

                }

                MultiValue::Exact(LayoutWidth::FitContent(_)) => {

                    // During intrinsic sizing, fit-content resolves to max-content

                }

                // For Auto or other values, use intrinsic size

            };

            // +spec:containing-block:5145c5 - percentage block-size ignored in content-sized containing blocks during intrinsic sizing

            // Resolve CSS height - use explicit value if set, otherwise fall back to intrinsic

                    use azul_css::props::basic::pixel::{DEFAULT_FONT_SIZE, PT_TO_PX};

                        // +spec:containing-block:7d5e79 - percentages behave as auto when containing block height is auto (cyclic percentage contribution)

                        // +spec:height-calculation:7d807b - css-sizing-3 §5.2.1: percentage heights behave as auto during intrinsic sizing (cyclic percentage contribution)

                        // Percentages and viewport units fall back to intrinsic (treated as auto)

                    }

                }

                // is equivalent to automatic size

                // is equivalent to automatic size

            };

            // Represent as a rectangular shape with the resolved dimensions

        }

    }

// Keep old name as an alias for backward compatibility

// +spec:height-calculation:1c899b - width and height properties specify the preferred size of the box

/// Calculates the used size of a single node based on its CSS properties and

/// the available space provided by its containing block.

///

/// // +spec:display-contents:71ccde - extrinsic sizing: size determined by context (containing block), not contents

///

/// This implementation correctly handles writing modes and percentage-based sizes

/// according to the CSS specification:

/// 1. `width` and `height` CSS properties are resolved to pixel values. Percentages are calculated

///    based on the containing block's PHYSICAL dimensions (`width` for `width`, `height` for

///    `height`), regardless of writing mode.

/// 2. The resolved physical `width` is then mapped to the node's logical CROSS size.

/// 3. The resolved physical `height` is then mapped to the node's logical MAIN size.

/// 4. A final `LogicalSize` is constructed from these logical dimensions.

// +spec:overflow:3c4f25 - auto box sizes: four auto-determined size types resolved here

// +spec:width-calculation:fb0629 - width/margin used values depend on box type, auto replaced by suitable value

/// M12.7: out-of-line auto-width-block inline size — `(cb.width - margins - borders -

/// padding).max(0.0)`. Extracted from calc_used_size's auto-width Block arm so the

/// `.max(0.0)` runs in a small fn (proven to lift correctly), with a FRESH pointer

/// deref (the huge calc_used_size body hoists/spills cb.width and the remill lift then

/// reads it back 0). Returns by f32 (D0/V0 — the standard scalar return), NOT an out-ptr:

/// the out-ptr version computed 800 correctly but the caller's reload was opt-forwarded

/// to the init 0.0 across the opaque call (the helper's `*out` lowers to a direct

/// linear-mem store not modeled as aliasing the caller's slot). The f32 return is the

/// call's SSA result, which opt cannot replace. (The earlier "f32-return mis-lift" worry

/// was the 2×f32 *struct* HFA — a single scalar f32 return is fine.)

#[inline(never)]