//! Final positioning of layout nodes (relative, absolute, and fixed schemes)

// +spec:positioning:79d47e - Implements relative, absolute, and fixed positioning schemes

use crate::solver3::layout_tree::LayoutNodeId;

use crate::debug_log;

use std::collections::BTreeMap;

use azul_core::{

    dom::{NodeId, NodeType},

    geom::{LogicalPosition, LogicalRect, LogicalSize},

    hit_test::ScrollPosition,

    resources::RendererResources,

    styled_dom::StyledDom,

};

use azul_css::{

    corety::LayoutDebugMessage,

    css::CssPropertyValue,

    props::{

        basic::pixel::PixelValue,

        layout::{LayoutPosition, LayoutWritingMode},

        property::{CssProperty, CssPropertyType},

    },

};

use crate::{

    font_traits::{FontLoaderTrait, ParsedFontTrait, TextLayoutCache},

    solver3::{

        fc::{layout_formatting_context, FloatingContext, LayoutConstraints, TextAlign},

        getters::{

            get_aspect_ratio_property, get_direction_property, get_display_property, get_writing_mode, get_position, MultiValue,

            get_css_top, get_css_bottom, get_css_left, get_css_right,

            get_css_height, get_css_width,

        },

        layout_tree::LayoutTree,

        LayoutContext, LayoutError, Result,

    },

};

#[derive(Debug, Default)]

pub(crate) struct PositionOffsets {

    pub(crate) top: Option<f32>,

    pub(crate) right: Option<f32>,

    pub(crate) bottom: Option<f32>,

    pub(crate) left: Option<f32>,

}

// +spec:positioning:94ef0f - position property: static|relative|absolute|sticky|fixed, initial static, applies to all elements except table-column-group/table-column

/// Looks up the `position` property using the compact-cache-aware getter.

// +spec:positioning:ba937d - positioned elements have position != static

    };

// +spec:positioning:bda1d5 - resolves inset properties (top/right/bottom/left) as inward offsets per CSS Position 3 §3.1

// +spec:positioning:bf9168 - resolves inset properties (top/right/bottom/left) to control positioned box location

// +spec:positioning:f8e0a1 - inset properties (top/right/bottom/left) resolved for positioned elements; auto = unconstrained

/// Reads and resolves `top`, `right`, `bottom`, `left` properties,

/// including percentages relative to the containing block's size, and em/rem units.

// +spec:positioning:7ec143 - top/right/bottom/left offset resolution with percentage against containing block

#[allow(clippy::field_reassign_with_default)] // struct built incrementally / test setup; a struct literal is not clearer here

    use azul_css::props::basic::pixel::{PhysicalSize, PropertyContext, ResolutionContext};

    use crate::solver3::getters::{

        get_element_font_size, get_parent_font_size, get_root_font_size,

    };

    };

    // Create resolution context with font sizes and containing block size

    // +spec:containing-block:d4b3b9 - percentage offsets resolve against CB width (left/right) or height (top/bottom)

    // Resolve offsets using compact-cache-aware getters

    // top/bottom use Height context (% refers to containing block height)

    };

    };

    // left/right use Width context (% refers to containing block width)

    };

    };

// +spec:block-formatting-context:f5f992 - Out-of-flow: floated or absolutely positioned boxes laid out outside normal flow

// +spec:positioning:bb19f8 - absolute/fixed positioning: out-of-flow, positioned relative to containing block/viewport

/// After the main layout pass, this function iterates through the tree and correctly

/// calculates the final positions of out-of-flow elements (`absolute`, `fixed`).

// +spec:positioning:5bfef3 - abspos elements use static position for auto offsets, resolve against nearest positioned ancestor CB

// +spec:positioning:7fff75 - Absolute positioning: removed from flow, offset relative to containing block, establishes new CB

// +spec:positioning:839cbb - absolute elements positioned/sized solely relative to their containing block, modified by inset properties

// +spec:positioning:898590 - absolute positioning takes elements out of flow and positions them relative to containing block

// +spec:positioning:c37c1b - abspos boxes laid out in containing block after its final size is determined

// +spec:positioning:cbe481 - absolute positioning removes elements from flow and positions them relative to containing block

// +spec:positioning:ebff77 - absolute positioning layout model (replaces old §6 abspos model)

// +spec:positioning:3b3ba4 - Absolute positioning: box offset from containing block, removed from normal flow; fixed positioning: CB = viewport

#[allow(clippy::too_many_lines, clippy::cognitive_complexity)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

/// # Panics

///

/// Panics if a resolved offset (`top`/`bottom`) is None where both edges are expected.

    use azul_css::props::style::StyleDirection;

    // Returns `()` (not Result<()>): inner fallible calls use skip-on-err (see above), so this fn

    // never propagates Err. Avoids the lift-fragile Result<(),LayoutError> Ok-niche read.

        };

        // +spec:positioning:1d87f6 - Fixed/absolute positioning schemes with box offset resolution (top/right/bottom/left)

        // +spec:positioning:8bde1d - absolute: out of flow, positioned by containing block

        // +spec:positioning:c11be9 - absolute positioning: effect of box offsets depends on which properties are auto (non-replaced) or intrinsic dimensions (replaced)

        // +spec:positioning:9020aa - "absolutely positioned" means position:absolute or position:fixed

            // is a grid container have their CB determined by grid-placement properties;

            // Taffy already handles this during grid layout, so skip re-positioning here.

            // Same applies to flex containers (Flexbox §4.1).

            {

                use azul_core::dom::FormattingContext;

            }

            // Get parent info before any mutable borrows

                    {

                    } else {

                    }

            };

            // +spec:containing-block:17a946 - fixed boxes use viewport as containing block

            // +spec:containing-block:83a32a - fixed positioning: containing block is viewport; absolute: nearest positioned ancestor or initial CB

            // +spec:containing-block:9b617d - fixed elements use viewport (initial fixed containing block)

            // +spec:containing-block:899e47 - fixed elements use viewport (initial fixed containing block)

            // +spec:containing-block:faa9a3 - fixed positioning falls back to initial containing block (viewport) when no ancestor establishes one

            // +spec:containing-block:faa9a3 - fixed positioning CB falls back to initial containing block (viewport) when no ancestor establishes one

            // +spec:positioning:067eab - CB for fixed = viewport, for absolute = nearest positioned ancestor

            // +spec:positioning:067eab - fixed CB is viewport; absolute CB is nearest positioned ancestor's padding-box

            // +spec:positioning:9777da - fixed positioning uses viewport as containing block

            // +spec:positioning:9777da - Fixed positioning uses viewport as containing block

            // +spec:positioning:9ccf9a - fixed-position CB is viewport (transform/will-change/contain could override, not yet implemented)

            // +spec:positioning:a68970 - fixed positioning uses viewport as containing block

            // +spec:positioning:8fff44 - fixed: same as absolute but positioned relative to viewport

            // +spec:positioning:744713 - fixed position uses viewport as containing block

            // +spec:positioning:f0ad47 - fixed elements use viewport as containing block; content outside viewport cannot be scrolled to

            // +spec:containing-block:df8387 - fixed positioning: containing block is the viewport

            } else {

                // skip-on-err (was `?`): a CB-resolution failure for one out-of-flow node skips

                // that node rather than aborting the whole layout. Lets this fn return `()`

                // (no Result<(),LayoutError> Ok-niche read, which the remill→wasm lift mis-lowers).

                }

            };

            // Get node again after containing block calculation

            // Calculate used size for out-of-flow elements. ALWAYS solve from

            // the containing block + own CSS + intrinsics: abs elements are

            // skipped by the in-flow pass, so a pre-existing `used_size` here

            // is junk from that skip (typically Some(0x0)) — trusting it made

            // an auto-sized abs box (`top/left` only) keep 0x0 forever and

            // its children disappear. §10.3.7: their used size never depends

            // on in-flow layout, so recomputing is deterministic.

                };

                // Store the calculated size in the tree node

            };

            // +spec:positioning:dc23fa - sizing/positioning into inset-modified containing block (§4)

            // +spec:positioning:623e45 - inset properties reduce the containing block into the inset-modified containing block

            // Resolve offsets using the now-known containing block size.

            // +spec:box-model:ae3899 - static position is the margin-edge position from normal flow

            // +spec:positioning:9a90a3 - static position: the position the element would have had in normal flow

            // +spec:positioning:ca3e89 - static-position rectangle uses block-start inline-start alignment (CSS2.1 hypothetical box)

            // Special case: If this is a fixed-position element and it has a positioned

            // parent, update static_pos to be relative to the parent's final absolute

            // position (content-box). The initial static_pos from process_out_of_flow_children

            // may include border/padding offsets, so we must always recalculate here.

            // +spec:box-model:ea2f43 - top + margin + border + padding + height + bottom = CB height

            // +spec:box-model:b4f5b3 - vertical constraint equation for abs-pos non-replaced elements

            // +spec:positioning:16d82c - vertical dimension constraint for abs-positioned non-replaced elements

            // +spec:positioning:8f474b - §10.6.4 vertical constraint for absolutely positioned non-replaced elements

            // +spec:positioning:50218d - absolute: top margin edge offset below containing block top edge

            // top + margin-top + border-top + padding-top + height + padding-bottom +

            // border-bottom + margin-bottom + bottom = containing block height

            // Extract all box_props values upfront to avoid borrow conflicts with tree.get_mut()

            // +spec:positioning:d730e5 - CB height is independent of the abspos element, so percentage heights always resolve

            // +spec:replaced-elements:7d8ba8 - §10.6.5: for absolutely positioned replaced

            // elements, height is determined first (as for inline replaced elements), so treat

            // it as "not auto" in the constraint equation even if CSS says auto.

            // +spec:overflow:941a06 - resolve auto inset properties: if only one is auto, solved to zero via constraint; if both auto, use static position

            // element_size is border-box (includes border + padding + content).

            // The constraint equation is:

            //   top + margin-top + border-box-height + margin-bottom + bottom = CB height

            // (border-top, padding-top, content-height, padding-bottom, border-bottom

            //  are all inside border-box-height)

            // +spec:height-calculation:44939a - set auto values for margin-top/margin-bottom to 0

            // +spec:height-calculation:2f6e10 - if bottom is auto, replace auto margin-top/margin-bottom with 0

            // +spec:box-model:3a9c2a - resolving auto insets: static position fallback when insets are auto

            // +spec:box-model:bd442c - weaker inset resolves to align margin box with inset-modified CB edge

            // +spec:height-calculation:93e91c - abs non-replaced height: auto margin centering, single auto margin solve, over-constrained ignore bottom

            // +spec:positioning:6e7732 - §10.6.4 vertical constraint equation for abspos non-replaced elements

            // +spec:positioning:b63d0f - absolute positioning with top:auto uses static position (change bars example)

            // +spec:positioning:da8a0c - resolving auto insets: normal alignment treated as start, so auto insets resolve to static position

            // +spec:positioning:820b22 - 10.6.4: absolutely positioned non-replaced elements vertical constraint equation and 6 rules

                // +spec:overflow:fc0c9e - over-constrained abspos: auto margins minimize overflow (CSS2.1 equivalent of Box Alignment 3 safe alignment)

                // +spec:positioning:88f760 - auto margins of absolutely-positioned boxes (vertical)

                // None are auto: over-constrained case

                // +spec:height-calculation:03c071 - none auto: equal auto margins, solve single auto margin, or ignore bottom if over-constrained

                // else: over-constrained, ignore bottom

                // +spec:intrinsic-sizing:566a43 - abspos auto height with non-auto insets: stretch-fit size

                // +spec:intrinsic-sizing:c7227f - except: if box has aspect-ratio, ratio-dependent axis uses max-content

                    MultiValue::Exact(azul_css::props::style::effects::StyleAspectRatio::Ratio(_))

                );

                // else: keep content-based height (max-content) per aspect-ratio exception

                // Update the element size with the resolved height

            // +spec:box-model:984243 - horizontal constraint equation for abs-pos non-replaced elements

            // +spec:positioning:3be194 - position abs replaced element after establishing width

            // Constraint: left + margin-left + border-left + padding-left + width +

            // +spec:width-calculation:1661b4 - constraint equation and six rules for abs-pos horizontal (§10.3.7)

            // left + margin-left + border-left + padding-left + width +

            //   padding-right + border-right + margin-right + right = CB width

            // Since element_size.width is border-box (border + padding + content),

            // simplifies to: left + margin-left + border_box_width + margin-right + right = CB width

            {

                // Get direction of containing block for over-constrained resolution

                    } else {

                            } else {

                            }

                        }

                    };

                            }

                        }

                    }

                };

                // +spec:replaced-elements:7d8ba8 - §10.3.8: for absolutely positioned replaced elements, width is determined

                // first (as for inline replaced), so treat as "not auto" in the constraint.

                    // +spec:positioning:88f760 - auto margins of absolutely-positioned boxes (horizontal)

                    // +spec:width-calculation:942c77 - abs-pos non-replaced width: auto margins, over-constrained resolution

                    // None of left/width/right are auto — solve for margins or handle over-constrained

                    // +spec:width-calculation:dff69d - §10.3.7 abs-pos non-replaced: none auto → equal auto margins, solve single auto margin, or over-constrained

                    // +spec:writing-modes:9c3b40 - abspos auto margins: if negative remaining in inline axis, start margin=0, end margin gets remainder

                        // +spec:positioning:ab47b3 - auto margins can be negative in absolute positioning

                        // Both margins auto: equal values unless negative

                            }

                        // Over-constrained: ignore right (LTR) or left (RTL)

                        }

                    }

                } else {

                    // +spec:overflow:f323cb - auto inset: align margin box to stronger inset edge (may overflow CB)

                    // +spec:width-calculation:bbf97a - set auto margins to 0 for abspos when left/width/right has auto

                    // Set auto margins to 0, apply six rules

                    // +spec:box-model:2da091 - if either inset is auto, auto margins resolve to zero

                    // +spec:intrinsic-sizing:087b57 - abspos auto margins resolve to 0 when any inset is auto

                    // +spec:width-calculation:0c29ce - set auto margins to 0, then apply six rules for abs pos width

                    // +spec:width-calculation:2b2852 - all three auto: set auto margins to 0, use static position for left (LTR)

                    // +spec:width-calculation:c120b3 - all three of left/width/right auto: set auto margins to 0, then use direction to pick static position

                        }

                        // +spec:intrinsic-sizing:566a43 - abspos auto width with non-auto insets: stretch-fit size

                        // +spec:intrinsic-sizing:c7227f - except: if box has aspect-ratio, ratio-dependent axis uses max-content

                            MultiValue::Exact(azul_css::props::style::effects::StyleAspectRatio::Ratio(_))

                        );

                            // width = cb_width - left - margin_left - margin_right - right

                        // else: keep content-based width (max-content) per aspect-ratio exception

                }

            }

            // The absolute box is now at its FINAL, definite size (§10.3.7 /

            // §10.6.4) — "abspos boxes laid out in containing block after its

            // final size is determined". The in-flow pass deliberately skips

            // abs subtrees, so THIS is the one authoritative interior layout:

            // against the solved box, unconditionally (before, a collapsed-

            // child heuristic left block interiors unlaid — children of an

            // abs box simply disappeared — and the flex path let the taffy

            // root re-derive the box's own height from content, clobbering

            // the §10.6.4 stretch-fit). The solved border-box size is

            // restored after the run precisely because a formatting-context

            // root may re-derive its own size; child positions are then

            // propagated from the final box (the interior run only writes

            // warm relative positions). The abs box's used size is

            // independent of its content, so this cannot loop.

                );

                // §10.6.4 rules 1 and 3: with height:auto and at most one

                // vertical inset, the used height IS the laid-out content

                // height — adopt it from the interior run (the pre-layout

                // value was the 0 placeholder). Rule 1 (bottom set, top

                // auto) then re-derives top with the REAL height.

                );

                );

    }

// +spec:positioning:5b0d7f - relative positioning: offset from normal flow position, siblings unaffected

// +spec:positioning:8afbe2 - Relative positioning preserves normal flow size and space; only visual offset applied after layout

// +spec:positioning:3502d5 - relative and absolute positioning supported for combined use

// +spec:positioning:b22222 - relative positioning: offset from static position, purely visual effect

// +spec:positioning:b814b6 - relative/absolute/fixed positioning scheme (CSS Positioned Layout Module Level 3)

/// Final pass to shift relatively positioned elements from their static flow position.

// +spec:block-formatting-context:60ccf9 - relative positioning shifts inline boxes as a unit after normal flow

// +spec:display-property:17239f - relative positioning offsets element after normal flow; abspos elements taken out of flow

// +spec:positioning:cbe066 - relative positioning implementation

///

/// Resolves percentage-based offsets for `top`, `left`, etc.

/// For relatively positioned elements, percentages are

/// relative to the dimensions of the parent element's content box.

// +spec:positioning:2d8e15 - relative positioning shifts elements as a unit after normal flow without affecting surrounding content

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

    use azul_css::props::style::StyleDirection;

    // NOTE: returns `()` (not `Result<()>`). This fn is Ok-always — its only `?` are on `Option`

    // inside `.and_then` closures, never propagating to the fn body. The previous `Result<(),

    // LayoutError>` return forced the `?` at the call site to read an Ok-niche discriminant, which

    // the remill→wasm lift mis-lowers (per-build, ASLR-dependent) → a FALSE Err that aborted the

    // whole layout in the web backend (rect=0). Matches sibling reposition_* fns that return ().

    // Iterate through all nodes. We need the index to modify the position map.

        // +spec:block-formatting-context:faa1cf - static boxes: top/right/bottom/left do not apply

        // Early continue for non-relative positioning

        // +spec:overflow:cfb09a - Sticky positioning uses relative-like offsets, clamped to nearest scrollport at scroll time

        // +spec:table-layout:6cb73b - position:relative effect on table elements is undefined; skip them

        // +spec:table-layout:718f91 - relative positioning on table-row/row-group shifts all contents

        {

            use azul_css::props::layout::LayoutDisplay;

                // +spec:positioning:4614dd - position does not apply to table-column-group or table-column boxes

                // Table-row and row-group elements DO support relative positioning:

                // the shift affects all contents including cells originating in the row.

                // Table-column, table-column-group, table-cell, and table-caption do not.

                    LayoutDisplay::TableColumnGroup

                        | LayoutDisplay::TableColumn

                        | LayoutDisplay::TableCell

                        | LayoutDisplay::TableCaption

                ) {

        }

        // Determine the containing block size for resolving percentages.

        // For `position: relative`, this is the parent's content box size.

                // Get parent's writing mode to correctly calculate its inner (content) size.

        // +spec:positioning:418c74 - inset percentages resolve against containing block size per axis; auto is unconstrained

        // Get a mutable reference to the position and apply the offsets.

        };

        // +spec:positioning:5eb813 - relative positioning offsets contents from normal flow position

        // +spec:positioning:a2e5f1 - relative positioning shifts element from static position (vs absolute/float)

        // top/bottom/left/right offsets are applied relative to the static position.

        // +spec:positioning:218b50 - Relative positioning: top=-bottom, left=-right, direction-dependent resolution, top wins over bottom

        // According to CSS 2.1 Section 9.4.3:

        // - For `top` and `bottom`: if both are specified, `top` wins and `bottom` is ignored

        // - For `left` and `right`: depends on direction (ltr/rtl)

        //   - In LTR: if both specified, `left` wins and `right` is ignored

        //   - In RTL: if both specified, `right` wins and `left` is ignored

        // +spec:overflow:53dffd - both left/right auto → used values are 0, boxes stay in original position

        // +spec:positioning:5a099e - negative offsets can cause overlapping (no clamping applied)

        // +spec:positioning:d189de - bottom offset for relative positioning is with respect to the box's own bottom edge

        // +spec:positioning:d80f47 - opposing inset values are negations: top wins over bottom, left/right per direction

        // +spec:positioning:ecc27c - relative positioning: left/right move box horizontally without changing size, left = -right

        // +spec:positioning:50218d - relative: offset from static position (top edges of box itself)

        // both auto → 0; one auto → negative of other; neither auto → bottom ignored (top wins)

        // +spec:positioning:ac768b - relative positioning: both auto→0, one auto→neg of other, neither→top wins; direction-aware left/right

        // +spec:positioning:e3727e - top/bottom: both auto→0, one auto→negative of other, neither auto→bottom ignored

        // Vertical positioning: `top` takes precedence over `bottom`

        // +spec:positioning:1732e8 - left/right for relatively positioned elements determined by 9.4.3 rules

        // Spec: "If the 'direction' property of the containing block is 'ltr', the value of 'left' wins"

        // Get the direction of the containing block (parent), not the element itself

                }

        // +spec:containing-block:6d4fb1 - over-constrained relative positioning: ltr→left wins, rtl→right wins

            StyleDirection::Ltr => {

            }

            StyleDirection::Rtl => {

            }

        }

        // +spec:overflow:f1e1ce - relative positioning may cause overflow:auto/scroll boxes to need scrollbars

        // Only apply the shift if there is a non-zero delta.

                node_index, initial_pos, *current_pos, delta_x, delta_y);

            // +spec:table-layout:ec2600 - For table-row-group, table-header-group, table-footer-group, or table-row,

            // the relative shift affects all contents of the box including table cells.

            // Propagate the delta to all descendant nodes.

            {

                use azul_css::props::layout::LayoutDisplay;

                    MultiValue::Exact(

                        LayoutDisplay::TableRowGroup

                        | LayoutDisplay::TableHeaderGroup

                        | LayoutDisplay::TableFooterGroup

                        | LayoutDisplay::TableRow

                    )

                );

                    // Shift all children (and their descendants) by the same delta

                    }

            }

    }

// +spec:overflow:bac4e5 - sticky view rectangle from inset properties relative to nearest scrollport

/// Finds the nearest scrollport (ancestor with overflow: scroll or auto) for a node.

/// Returns the content-box rect of the scrollport, or the viewport if none found.

    use crate::solver3::getters::{get_overflow_x, get_overflow_y};

    use azul_css::props::layout::LayoutOverflow;

        };

        };

            MultiValue::Exact(LayoutOverflow::Scroll | LayoutOverflow::Auto)

            MultiValue::Exact(LayoutOverflow::Scroll | LayoutOverflow::Auto)

        );

            // Content-box = margin-box pos + border + padding, size - border - padding

            );

            );

    }

/// Find the scroll offset of the nearest scroll container ancestor.

/// Returns the scroll offset as a `LogicalPosition` (how far the content has scrolled).

///

/// `children_rect.origin` IS that offset (see

/// `ScrollManager::get_scroll_states_for_dom`), positive meaning "scrolled

/// down/right". `parent_rect.origin` is an ABSOLUTE window coordinate and must

/// NOT be subtracted from it — doing so mixed two spaces and reported a

/// container's own y as a scroll amount for every scroller below the top of

/// the window.

        } else {

        }

    }

/// Adjusts positions of sticky-positioned elements based on scroll offset.

///

/// Sticky positioning works like relative positioning, but the element's position

/// is constrained by its inset properties (top/right/bottom/left) relative to the

/// nearest scrollport (scroll container ancestor). The margin box is further

/// constrained to remain within the containing block.

///

/// +spec:position-sticky:9449f1 - for sticky positioning, insets represent offsets from scrollport edge

/// +spec:position-sticky:75412d - multiple sticky boxes in same container offset independently

/// +spec:box-model:af9af8 - sticky positioning: shift element to stay within sticky view rectangle, margin box constrained to containing block

/// +spec:overflow:bac4e5 - compute sticky view rectangle, clamp end-edge insets to border box size

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

    // Returns `()` (not `Result<()>`): Ok-always (its only `?` is Option-`?` in an `.and_then`

    // closure). Avoids the lift-fragile Result<(),LayoutError> Ok-niche read at the call site.

        };

        // Find the nearest scrollport for this sticky element

        );

        // The containing block for percentage resolution is the parent's content box

                );

        // Resolve inset properties (top, right, bottom, left)

        // Get the scroll offset from the nearest scroll container

        };

        // For each side: if inset is not auto, clamp the border edge to stay

        // within the sticky view rectangle (scrollport inset by the specified amount).

        // The scroll offset shifts the effective scrollport position.

        // Constrain: the margin box must remain within the containing block

                node_index, static_pos, *current_pos);

    }

// +spec:positioning:22f165 - absolute/fixed containing block: nearest positioned ancestor's padding-box, or initial CB

/// Helper to find the containing block for an absolutely positioned element.

/// CSS 2.1 Section 10.1: The containing block for absolutely positioned elements

/// is the padding box of the nearest positioned ancestor.

// +spec:containing-block:10af51 - absolutely positioned element's CB is nearest positioned ancestor

// +spec:positioning:2d0dbb - containing block for abspos is padding-box of nearest positioned ancestor, or initial CB

// +spec:positioning:3ac06c - abspos positioned relative to containing block ignoring fragmentation breaks

// +spec:positioning:d7e4b4 - containing block of abspos element is always definite (returns concrete LogicalRect)

// +spec:positioning:fc9dba - containing block resolution for absolutely positioned boxes

///

/// Returns a `LogicalRect` representing the padding-box of the nearest

/// positioned ancestor, or the viewport (initial containing block) if none exists.

/// This is the unified entry point used by both sizing and positioning phases.

// +spec:containing-block:18ae8e - Absolute positioning: abs-pos box establishes new CB for normal flow and abs-pos (but not fixed) descendants

// +spec:containing-block:b6cb8b - containing block for abs-pos is nearest positioned ancestor

// +spec:display-property:5a39bc - containing block for abspos is nearest positioned ancestor or initial containing block

// +spec:positioning:09a0fa - Absolute positioning: CB is padding-box of nearest positioned ancestor

// +spec:positioning:467cb1 - Containing block for abs pos = nearest positioned ancestor or initial CB

// +spec:positioning:99d0bb - containing block for absolute elements is nearest positioned ancestor

// +spec:positioning:92e099 - containing block for abs pos is nearest positioned ancestor or initial CB

// +spec:positioning:f57523 - containing block of abspos element is always definite (returns concrete LogicalRect)

// +spec:width-calculation:bf1aa6 - abspos CB is nearest positioned ancestor, else initial CB

// Containing block for absolutely positioned elements is established by

// nearest positioned ancestor (relative/absolute/fixed), or initial containing block if none.

// +spec:positioning:8f50de - relatively positioned parent serves as containing block for abspos descendants

// +spec:containing-block:6bcb0c - containing block is padding edge of nearest positioned ancestor, or initial containing block if none

// +spec:containing-block:bf17e5 - containing block for abspos is padding box of nearest positioned ancestor, or initial CB

// +spec:containing-block:d0f92d - containing block for positioned box is nearest positioned ancestor, or initial containing block

// +spec:containing-block:d7e013 - containing block for positioned box is nearest positioned ancestor or initial CB

// +spec:containing-block:05bc0d - positioning an element changes which ancestor establishes the CB for its descendants

// +spec:positioning:355ee4 - CB for abspos is padding edge of nearest positioned ancestor, or initial CB

// +spec:positioning:383794 - Containing block for abspos is nearest positioned ancestor, or initial containing block if none

// +spec:positioning:5b3e43 - Containing block for abs-pos is padding box of nearest positioned ancestor, or initial CB

// +spec:positioning:882e67 - containing block for abs pos is nearest positioned ancestor or initial CB

// +spec:positioning:292c5c - relative parent serves as containing block for absolute descendants

// +spec:positioning:00ce38 - CB for absolute is padding edge of nearest positioned ancestor

    // +spec:positioning:748d87 - walk up to nearest positioned ancestor for CB

    // +spec:positioning:aa361e - values other than static make a box positioned and establish an abspos containing block

            // calculated_positions stores margin-box positions

            // used_size is the border-box size

            // +spec:containing-block:6bcb0c - containing block formed by padding edge of nearest positioned ancestor

            // +spec:positioning:df1921 - abs-pos percentage widths resolve against padding box of containing block

            // Calculate padding-box origin (margin-box + border)

            );

            // Calculate padding-box size (border-box - borders)

            );

    }

    // +spec:positioning:3d88c9 - abspos available space is always definite (viewport or positioned ancestor padding box)

    // No positioned ancestor found: fall back to initial containing block (viewport)

    // +spec:containing-block:141dcc - absolute element with no positioned ancestor uses initial containing block

    // +spec:containing-block:657f2f - containing block becomes initial containing block when no positioned ancestors

    // +spec:containing-block:7f5090 - if no ancestor establishes one, absolute positioning CB is initial containing block

    // +spec:containing-block:7f5090 - fallback to initial containing block when no positioned ancestor

    // +spec:containing-block:ad5ebc - no positioned ancestor: containing block becomes the initial containing block

    // +spec:display-property:813192 - abspos containing block falls back to initial containing block (viewport) when no positioned ancestor

#[cfg(test)]

#[allow(clippy::float_cmp, clippy::too_many_lines)]

mod autotest_generated {

    use azul_core::dom::{Dom, FormattingContext, IdOrClass};

    use super::*;

    use crate::solver3::{

        geometry::{EdgeSizes, MarginAuto, PackedBoxProps, ResolvedBoxProps},

        layout_tree::{LayoutNodeCold, LayoutNodeHot, LayoutNodeWarm},

        pos_set, PositionVec, POSITION_UNSET,

    };

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

    // Fixtures

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

    fn close(a: f32, b: f32, eps: f32) -> bool {

        (a - b).abs() <= eps

    }

    fn viewport() -> LogicalRect {

        LogicalRect::new(

            LogicalPosition::new(0.0, 0.0),

            LogicalSize::new(800.0, 600.0),

        )

    }

    fn styled(dom: Dom, css_str: &str) -> StyledDom {

        let mut dom = dom;

        let (css, _warnings) = azul_css::parser2::new_from_str(css_str);

        StyledDom::create(&mut dom, css)

    }

    fn div_class(class: &str) -> Dom {

        Dom::create_div().with_ids_and_classes(vec![IdOrClass::Class(class.into())].into())

    }

    fn body_class(class: &str) -> Dom {

        Dom::create_body().with_ids_and_classes(vec![IdOrClass::Class(class.into())].into())

    }

    /// Structural lookup — never hard-code `CompactDom` pre-order indices.

    fn node_by_class(sd: &StyledDom, class: &str) -> NodeId {

        let container = sd.node_data.as_container();

        for i in 0..sd.node_data.len() {

            let id = NodeId::new(i);

            let ids_and_classes = container[id].get_ids_and_classes();

            let hit = ids_and_classes

                .as_ref()

                .iter()

                .any(|ioc| matches!(ioc, IdOrClass::Class(c) if c.as_str() == class));

            if hit {

                return id;

            }

        }

        panic!("no node with class {class:?}");

    }

    fn edges(top: f32, right: f32, bottom: f32, left: f32) -> EdgeSizes {

        EdgeSizes {

            top,

            right,

            bottom,

            left,

        }

    }

    fn uniform(v: f32) -> EdgeSizes {

        edges(v, v, v, v)

    }

    fn bp(margin: EdgeSizes, padding: EdgeSizes, border: EdgeSizes) -> PackedBoxProps {

        PackedBoxProps::pack(&ResolvedBoxProps {

            margin,

            padding,

            border,

            margin_auto: MarginAuto::default(),

        })

    }

    fn bp_auto_margins(margin_auto: MarginAuto) -> PackedBoxProps {

        PackedBoxProps::pack(&ResolvedBoxProps {

            margin: uniform(0.0),

            padding: uniform(0.0),

            border: uniform(0.0),

            margin_auto,

        })

    }

    fn hot(parent: Option<usize>, dom_node_id: Option<NodeId>) -> LayoutNodeHot {

        LayoutNodeHot {