//! CSS `calc()` expression evaluator.

//!

//! This module implements a two-pass stack-machine evaluator for `calc()` expressions.

//! It resolves `CalcAstItem` slices (flat, parenthesised AST) into a single `f32` pixel value.

//!

//! **Resolution context**: Em/rem units are resolved using per-node font sizes that are

//! captured lazily during style translation and stored alongside the AST pointer passed

//! to taffy. Percentages use the `basis` value provided by taffy (container width/height).

use azul_css::props::{

    basic::{

        pixel::PT_TO_PX,

        PixelValue, SizeMetric,

    },

    layout::dimensions::{CalcAstItem, CalcAstItemVec},

};

/// CSS reference pixels per inch (96 px/in per CSS spec).

const PX_PER_INCH: f32 = 96.0;

/// Centimetres per inch.

const CM_PER_INCH: f32 = 2.54;

/// Millimetres per inch.

const MM_PER_INCH: f32 = 25.4;

/// Font-size context captured at style-translation time and stored alongside the calc AST.

///

/// Taffy's `resolve_calc_value` callback only receives `(*const (), f32)` — no node id.

/// We therefore bundle the per-node font sizes into the heap-pinned data that the opaque

/// pointer references, so the evaluator can resolve `em` / `rem` correctly.

#[derive(Debug, Clone)]

#[repr(C)]

pub struct CalcResolveContext {

    /// The calc AST items (flat stack-machine representation).

    pub items: CalcAstItemVec,

    /// Element's computed `font-size` in px — used for `em` resolution.

    pub em_size: f32,

    /// Root element's computed `font-size` in px — used for `rem` resolution.

    pub rem_size: f32,

}

/// Internal intermediate representation: a number or an operator (after value resolution).

#[derive(Clone, Debug)]

enum CalcFlatItem {

    Num(f32),

    Op(CalcOp),

}

/// Arithmetic operators.

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

enum CalcOp {

    Add,

    Sub,

    Mul,

    Div,

}

/// Evaluate a `CalcResolveContext` using the given `basis` (the "100 %" reference value,

/// e.g. containing-block width for `width: calc(…)`).

#[inline(never)] // M12.7: keep out of calc_used_size — its loop/jump-table inlined into the huge fn forces a remill PC-dispatch loop that mis-delivers auto_w

/// Stack-machine evaluator for a flat `CalcAstItem` slice.

///

/// `basis`    — the "100 %" reference value (e.g. containing-block width).

/// `em_size`  — element's computed font-size (for `em`).

/// `rem_size` — root element's computed font-size (for `rem`).

///

/// Two-pass approach with correct operator precedence:

///   Pass 1: evaluate `*` and `/`

///   Pass 2: evaluate `+` and `-`

/// Parenthesised sub-expressions are resolved recursively.

#[inline(never)] // M12.7: keep out of calc_used_size — its loop/jump-table inlined into the huge fn forces a remill PC-dispatch loop that mis-delivers auto_w

    // Convert into a working vec of resolved numbers and operators.

            CalcAstItem::BraceOpen => {

                // Find matching BraceClose and recurse

                    }

                }

                // items[start..j] is the inner sub-expression (excl. braces)

            }

        }

    }

    // Pass 1: resolve * and /

            // Apply to previous Num in pass2 and next Num in flat

            {

                    CalcOp::Div => {

                        } else {

                        }

                    }

                };

    }

    // Pass 2: resolve + and -

    };

        {

            }

    }

/// Resolve a single `PixelValue` to `f32` pixels inside a `calc()` expression.

///

/// - `basis`    — the "100 %" reference (containing-block width or height)

/// - `em_size`  — element's computed font-size (for `em` units)

/// - `rem_size` — root element's computed font-size (for `rem` units)

        SizeMetric::Vw | SizeMetric::Vh | SizeMetric::Vmin | SizeMetric::Vmax => {

            // Viewport units: fallback — proper resolution requires viewport context

        }

    }

/// Like `resolve_pixel_value`, but with proper viewport unit resolution.

#[inline(never)] // M12.7: keep out of calc_used_size — its loop/jump-table inlined into the huge fn forces a remill PC-dispatch loop that mis-delivers auto_w

    }