atmos/os_lib/layout/

values.rs

// 分割: layout.rs より機械的に移動（2026-07-16 リファクタ フェーズ4）。
// ロジック不変。可視性のみ pub(crate) へ昇格し、親が pub(crate) use で再エクスポート。
use super::*;

#[derive(Debug, Clone)]
pub(crate) enum LengthValue {
    Auto,
    Px(i32),
    Percent(f32),
    /// min-content: 折返しを最大化した最小内容幅。
    MinContent,
    /// max-content: 折返しなしの最大内容幅。
    MaxContent,
    /// fit-content: min(max-content, available) を clamp。
    FitContent,
    /// fit-content(length): min(max-content, max(min-content, length))。
    FitContentWith(alloc::boxed::Box<LengthValue>),
    /// `calc()` / `min()` / `max()` / `clamp()`。containing width が必要なため
    /// 式文字列のまま保持し、resolve_length_value で評価する。
    MathExpr(String),
}

/// 長さのプロパティを読み、`em` を**要素自身の文字サイズ**で px へ置き換えて返す。
///
/// 【2026-10-04】`parse_px_like` は `em` を常に 16px で換算する。CSS Values 4 §6.1.1
/// では font-size 以外のプロパティの `em` は要素自身の計算済み font-size 基準。
/// width/height/min/max/gap を読む箇所はこれを通す
/// （margin/padding/border は `style_box_edges` で同じ処理をしている）。
/// 試験: `tests/src/test_layout_em_units.rs`
pub(crate) fn len_value(node: &StyledNode, name: &str) -> Option<String> {
    let v = node.value_ref(name)?;
    // 小文字化した写しを作らずに "em" の有無を見る（レイアウトの最頻出の経路。2026-10-18）。
    if !v.as_bytes().windows(2).any(|w| w.eq_ignore_ascii_case(b"em")) {
        return Some(String::from(v));
    }
    let v = String::from(v);
    let font_px = node
        .value("font-size")
        .and_then(|f| parse_font_size_u32(&f))
        .unwrap_or(16) as f32;
    Some(crate::os_lib::web_engine::css_units::resolve_em_lengths(&v, font_px))
}

pub(crate) fn parse_length_value<S: AsRef<str>>(value: Option<S>) -> Option<LengthValue> {
    let v = value?;
    let t = v.as_ref().trim();
    if t.is_empty() {
        return None;
    }
    if t.eq_ignore_ascii_case("auto") {
        return Some(LengthValue::Auto);
    }
    if t.eq_ignore_ascii_case("min-content") {
        return Some(LengthValue::MinContent);
    }
    if t.eq_ignore_ascii_case("max-content") {
        return Some(LengthValue::MaxContent);
    }
    if t.eq_ignore_ascii_case("fit-content") {
        return Some(LengthValue::FitContent);
    }
    if t.len() >= 13
        && t.get(..12).is_some_and(|h| h.eq_ignore_ascii_case("fit-content("))
        && t.ends_with(')')
    {
        let inner = t.get(12..t.len() - 1).unwrap_or("").trim();
        if let Some(parsed) = parse_length_value(Some(inner)) {
            return Some(LengthValue::FitContentWith(alloc::boxed::Box::new(parsed)));
        }
    }
    if is_css_math_func(t) {
        return Some(LengthValue::MathExpr(String::from(t)));
    }
    if let Some(num) = t.strip_suffix('%') {
        if let Ok(pct) = num.trim().parse::<f32>() {
            return Some(LengthValue::Percent(pct / 100.0));
        }
        return None;
    }
    parse_px_like(t).map(LengthValue::Px)
}

pub(crate) fn resolve_length_value(value: LengthValue, base: i32) -> Option<i32> {
    resolve_length_value_with_font(value, base, 16.0)
}

pub(crate) fn resolve_length_value_with_font(value: LengthValue, base: i32, font_px: f32) -> Option<i32> {
    match value {
        LengthValue::Auto => None,
        LengthValue::Px(px) => Some(px),
        LengthValue::Percent(pct) => Some(round_f32_to_i32((base as f32) * pct)),
        // 内容ベースのキーワードは base（コンテナ幅）からは解けない。呼び出し側で
        // 内容計測して扱うため、min/max 制約としては None（無制約）扱いにする。
        LengthValue::MinContent
        | LengthValue::MaxContent
        | LengthValue::FitContent
        | LengthValue::FitContentWith(_) => None,
        LengthValue::MathExpr(expr) => crate::os_lib::css::eval_css_math_with_font(&expr, base, font_px),
    }
}

pub(crate) fn min_max(value: i32, min_v: Option<i32>, max_v: Option<i32>) -> i32 {
    let mut v = value;
    if let Some(min_v) = min_v {
        v = v.max(min_v);
    }
    if let Some(max_v) = max_v {
        v = v.min(max_v);
    }
    v
}

/// aspect-ratio 値を (num, den) の正の f32 ペアへ解釈する。`16/9` / `1.5` 形式。
/// 不正・ゼロ・負は None。
pub(crate) fn parse_aspect_ratio(s: &str) -> Option<(f32, f32)> {
    let t = s.trim();
    if t.is_empty() || t.eq_ignore_ascii_case("auto") {
        return None;
    }
    let (num, den) = if let Some((ns, ds)) = t.split_once('/') {
        (
            ns.trim().parse::<f32>().ok()?,
            ds.trim().parse::<f32>().ok()?,
        )
    } else {
        (t.parse::<f32>().ok()?, 1.0)
    };
    if num > 0.0 && den > 0.0 {
        Some((num, den))
    } else {
        None
    }
}

pub(crate) fn round_f32_to_i32(value: f32) -> i32 {
    if value >= 0.0 {
        (value + 0.5) as i32
    } else {
        (value - 0.5) as i32
    }
}

/// flex の gap を (row_gap, column_gap) px で返す。`gap` ショートハンド + `row-gap`/`column-gap`。
/// `%` は `base`（コンテナ content 幅）基準で解決する。
pub(crate) fn parse_flex_gap(node: &StyledNode, base: i32) -> (i32, i32) {
    fn px(s: &str, base: i32) -> i32 {
        match parse_length_value(Some(String::from(s.trim()))) {
            Some(LengthValue::Px(p)) => p,
            Some(LengthValue::Percent(pct)) => round_f32_to_i32(base as f32 * pct).max(0),
            _ => 0,
        }
    }
    let (mut row, mut col) = (0, 0);
    if let Some(g) = len_value(node, "gap") {
        let toks: Vec<&str> = g.split_whitespace().collect();
        if toks.len() == 1 {
            row = px(toks[0], base);
            col = row;
        } else if toks.len() >= 2 {
            row = px(toks[0], base);
            col = px(toks[1], base);
        }
    }
    if let Some(rg) = len_value(node, "row-gap") {
        row = px(&rg, base);
    }
    if let Some(cg) = len_value(node, "column-gap") {
        col = px(&cg, base);
    }
    (row, col)
}

pub(crate) fn resolve_edge(s: &str, base: i32) -> Option<i32> {
    match parse_length_value(Some(String::from(s))) {
        Some(LengthValue::Px(px)) => Some(px),
        Some(LengthValue::Percent(pct)) if base > 0 => Some(round_f32_to_i32(base as f32 * pct)),
        _ => None,
    }
}

pub(crate) fn is_css_math_func(s: &str) -> bool {
    let t = s.trim();
    t.starts_with("calc(") || t.starts_with("min(") || t.starts_with("max(") || t.starts_with("clamp(")
        || t.starts_with("abs(") || t.starts_with("sign(") || t.starts_with("round(")
        || t.starts_with("mod(") || t.starts_with("rem(")
}

pub(crate) fn apply_box_value(value: Option<String>, edges: &mut EdgeSizes, base: i32) {
    let Some(v) = value else { return };
    // calc()/min()/max()/clamp()/abs()/sign()/round()/mod()/rem() を単一値として扱う
    let vt = v.trim();
    if is_css_math_func(vt) {
        if let Some(px) = crate::os_lib::css::eval_css_math(vt, base) {
            edges.top = px;
            edges.right = px;
            edges.bottom = px;
            edges.left = px;
        }
        return;
    }
    let parts: Vec<&str> = v.split_whitespace().collect();
    if parts.is_empty() {
        return;
    }
    // 【2026-10-04】値の位置を保つ。以前は解釈できない値（`auto`）を filter_map で
    // 読み飛ばして詰めていたため、`margin:0 auto 1.5rem` が `[0, 24]` の 2 値扱い
    // （上下 0・左右 24）になり、下マージンが消えていた（sugi-lab.net の研究テーマの
    // カードで見出しがアイコンにくっついた）。`auto` の辺は触らない
    // （左右の auto は中央寄せの処理が別に扱う）。
    let vals: Vec<Option<i32>> = parts.iter().map(|p| resolve_edge(p, base)).collect();
    if vals.iter().all(|v| v.is_none()) {
        return;
    }
    let at = |i: usize| vals.get(i).copied().flatten();
    let (top, right, bottom, left) = match vals.len() {
        1 => (at(0), at(0), at(0), at(0)),
        2 => (at(0), at(1), at(0), at(1)),
        3 => (at(0), at(1), at(2), at(1)),
        _ => (at(0), at(1), at(2), at(3)),
    };
    if let Some(v) = top {
        edges.top = v;
    }
    if let Some(v) = right {
        edges.right = v;
    }
    if let Some(v) = bottom {
        edges.bottom = v;
    }
    if let Some(v) = left {
        edges.left = v;
    }
}

pub(crate) fn apply_edge_value(value: Option<String>, edge: &mut i32, base: i32) {
    if let Some(v) = value {
        let t = v.trim();
        if is_css_math_func(t) {
            if let Some(px) = crate::os_lib::css::eval_css_math(t, base) {
                *edge = px;
            }
        } else if let Some(px) = resolve_edge(t, base) {
            *edge = px;
        }
    }
}

pub(crate) fn parse_px_like(s: &str) -> Option<i32> {
    let t = s.trim();
    if t.is_empty() {
        return None;
    }
    // `border-width`/`column-rule-width`等のキーワード値（丸ごと未対応
    // だった）。`border`ショートハンド〔`css/shorthand.rs`の`parse_border_
    // shorthand`〕は既にこれらを`1px`/`3px`/`5px`へ変換していたが、
    // `border-width: thin;`のように longhand を単独指定した場合は
    // `parse_length_value`（このヘルパを内部で使う）が`t.parse::<f32>()`
    // 失敗で`None`を返し、幅が未設定のまま（暗黙の初期値へフォールバック）
    // になっていた。`outline-width`（`web_engine/helpers.rs`の
    // `parse_outline`）側は既にこの3キーワードへ対応済みで、`border-width`
    // 側にだけ同型の兄弟ギャップが残っていた。2026-07-17 発見・実装。
    match t {
        "thin" => return Some(1),
        "medium" => return Some(3),
        "thick" => return Some(5),
        _ => {}
    }
    if let Some(num) = t.strip_suffix("px") {
        return num.trim().parse::<f32>().ok().map(round_f32_to_i32);
    }
    if let Some(num) = t.strip_suffix("vh") {
        let h = VIEWPORT_HINT_H.load(AtomicOrdering::Relaxed);
        return num
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| round_f32_to_i32((v / 100.0) * h as f32));
    }
    if let Some(num) = t.strip_suffix("vw") {
        let w = VIEWPORT_HINT_W.load(AtomicOrdering::Relaxed);
        return num
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| round_f32_to_i32((v / 100.0) * w as f32));
    }
    // `vmin`/`vmax`（丸ごと未対応だった。`vh`/`vw`は実装済みなのに、同じ
    // ビューポート相対単位の仲間である`vmin`/`vmax`だけ抜けていた
    // 「兄弟ギャップ」。レスポンシブデザインでよく使われる単位で、
    // 未対応時は末尾の裸数値パースにフォールバックして失敗し`None`に
    // なっていた。`in`（インチ、絶対単位）の`strip_suffix`判定より前に
    // 置く必要がある——`vmin`/`vmax`は末尾2文字がそれぞれ`in`/`ax`であり、
    // 特に`vmin`は`in`判定を先にすると`"50vmin"`が誤って`"50vm" + "in"`
    // として吸収されてしまう）。2026-07-16 発見・実装。
    if let Some(num) = t.strip_suffix("vmin") {
        let w = VIEWPORT_HINT_W.load(AtomicOrdering::Relaxed);
        let h = VIEWPORT_HINT_H.load(AtomicOrdering::Relaxed);
        let m = w.min(h);
        return num
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| round_f32_to_i32((v / 100.0) * m as f32));
    }
    if let Some(num) = t.strip_suffix("vmax") {
        let w = VIEWPORT_HINT_W.load(AtomicOrdering::Relaxed);
        let h = VIEWPORT_HINT_H.load(AtomicOrdering::Relaxed);
        let m = w.max(h);
        return num
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| round_f32_to_i32((v / 100.0) * m as f32));
    }
    if let Some(num) = t.strip_suffix("rem") {
        return num
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| round_f32_to_i32(v * 16.0));
    }
    if let Some(num) = t.strip_suffix("em") {
        return num
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| round_f32_to_i32(v * 16.0));
    }
    // 絶対長さ単位（`in`/`cm`/`mm`/`pt`/`pc`/`q`。丸ごと未対応だった。CSS
    // Values and Units の規定どおり `96px = 1in` を基準に換算する
    // （`font.rs`等では独自係数の`pt`扱いがあり得るが、こちらは`width`/
    // `margin`等の一般長さ値のための正規換算）。2026-07-16 発見・実装。
    if let Some(num) = t.strip_suffix("in") {
        return num.trim().parse::<f32>().ok().map(|v| round_f32_to_i32(v * 96.0));
    }
    if let Some(num) = t.strip_suffix("cm") {
        return num
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| round_f32_to_i32(v * 96.0 / 2.54));
    }
    if let Some(num) = t.strip_suffix("mm") {
        return num
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| round_f32_to_i32(v * 96.0 / 25.4));
    }
    if let Some(num) = t.strip_suffix("pt") {
        return num
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| round_f32_to_i32(v * 96.0 / 72.0));
    }
    if let Some(num) = t.strip_suffix("pc") {
        return num.trim().parse::<f32>().ok().map(|v| round_f32_to_i32(v * 16.0));
    }
    if let Some(num) = t.strip_suffix('q') {
        return num
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| round_f32_to_i32(v * 96.0 / 101.6));
    }
    t.parse::<f32>().ok().map(round_f32_to_i32)
}

/// letter-spacing 値を px(i32, 負も可) として解釈する。`normal`/未指定/不正は 0。
/// `font_px` は要素自身の算出フォントサイズ（`em` 単位の計算に使用）。
/// `calc()`/`min()`/`max()`/`clamp()` にも対応（`containing_width` は % 解決の基準、
/// letter-spacing/word-spacing は通常 % を取らないため主に `calc(1px + 1px)` 等の用途）。
pub(crate) fn parse_letter_spacing_with_font(val: Option<&str>, containing_width: i32, font_px: f32) -> i32 {
    match val {
        None => 0,
        Some(s) => {
            let t = s.trim();
            if t.is_empty() || t.eq_ignore_ascii_case("normal") {
                0
            } else if is_css_math_func(t) {
                crate::os_lib::css::eval_css_math_with_font(t, containing_width, font_px).unwrap_or(0)
            } else if let Some(num) = t.strip_suffix("em") {
                num.trim()
                    .parse::<f32>()
                    .ok()
                    .map(|v| round_f32_to_i32(v * font_px))
                    .unwrap_or(0)
            } else {
                parse_px_like(t).unwrap_or(0)
            }
        }
    }
}

pub(crate) fn parse_letter_spacing_ctx(val: Option<&str>, containing_width: i32) -> i32 {
    parse_letter_spacing_with_font(val, containing_width, 16.0)
}

/// 後方互換用（`containing_width` 不明な呼び出し元向け。calc() の % は解決できず0扱いになる）。
pub(crate) fn parse_letter_spacing(val: Option<&str>) -> i32 {
    parse_letter_spacing_ctx(val, 0)
}

/// word-spacing の値を px としてパース（letter-spacing と同じ規則）。
pub(crate) fn parse_word_spacing_with_font(val: Option<&str>, containing_width: i32, font_px: f32) -> i32 {
    parse_letter_spacing_with_font(val, containing_width, font_px)
}

/// word-spacing の値を px としてパース(letter-spacing と同じ規則)。
pub(crate) fn parse_word_spacing_ctx(val: Option<&str>, containing_width: i32) -> i32 {
    parse_letter_spacing_ctx(val, containing_width)
}

/// 後方互換用（`containing_width` 不明な呼び出し元向け）。
pub(crate) fn parse_word_spacing(val: Option<&str>) -> i32 {
    parse_letter_spacing_ctx(val, 0)
}

/// font-size の値を u32 としてパースする。
///
/// 【2026-07-28 二重実装を解消】以前はこの関数が `px` と `pt` しか解釈せず、
/// `3rem` のような値で `None` を返して既定の 16px にフォールバックしていた。
/// 一方で描画側は `css_units::parse_font_size`（px/pt/rem/em/単位なし対応）を
/// 使っていたため、**レイアウトは 16px・描画は 48px** という食い違いが生じ、
/// `.hero-title` が 1 行分（高さ 19px）しか場所を確保しないまま 3 行に
/// 折り返されて、後続要素と重なっていた。
///
/// 同じ意味の解釈を 2 箇所に持つとこの種の不整合が必ず起きるため、
/// レイアウト側も描画側と**同一の実装**へ委譲する。
pub(crate) fn parse_font_size_u32(s: &str) -> Option<u32> {
    crate::os_lib::web_engine::css_units::parse_font_size(s)
}

pub(crate) fn shift_layout_box(layout: &mut LayoutBox, dx: i32, dy: i32) {
    layout.dimensions.content.x += dx;
    layout.dimensions.content.y += dy;
    for child in &mut layout.children {
        shift_layout_box(child, dx, dy);
    }
}

pub(crate) fn get_image_size(data: &[u8]) -> Option<(i32, i32)> {
    if data.len() >= 24 && &data[0..8] == b"\x89PNG\r\n\x1a\n" && &data[12..16] == b"IHDR" {
        let w = u32::from_be_bytes(data[16..20].try_into().ok()?) as i32;
        let h = u32::from_be_bytes(data[20..24].try_into().ok()?) as i32;
        return Some((w, h));
    }
    if data.len() >= 26 && &data[0..2] == b"BM" {
        let w = i32::from_le_bytes(data[18..22].try_into().ok()?);
        let h = i32::from_le_bytes(data[22..26].try_into().ok()?);
        if w > 0 && h != 0 {
            return Some((w, h.abs()));
        }
    }
    if data.len() >= 4 && data[0] == 0xFF && data[1] == 0xD8 {
        let mut i = 2;
        while i + 8 < data.len() {
            if data[i] != 0xFF {
                i += 1;
                continue;
            }
            let marker = data[i + 1];
            if marker == 0xD9 || marker == 0xDA {
                break;
            }
            if marker == 0x00 || (0xD0..=0xD7).contains(&marker) {
                i += 2;
                continue;
            }
            let len = u16::from_be_bytes([data[i + 2], data[i + 3]]) as usize;
            if (0xC0..=0xCF).contains(&marker)
                && marker != 0xC4
                && marker != 0xC8
                && marker != 0xCC
                && i + 9 < data.len()
            {
                let h = u16::from_be_bytes([data[i + 5], data[i + 6]]) as i32;
                let w = u16::from_be_bytes([data[i + 7], data[i + 8]]) as i32;
                return Some((w, h));
            }
            i += 2 + len;
        }
    }
    None
}

pub(crate) fn get_styled_node_text(node: &StyledNode) -> String {
    let mut text = String::new();
    if let NodeType::Text(t) = &node.node.node_type {
        text.push_str(t);
    }
    for child in &node.children {
        text.push_str(&get_styled_node_text(child));
    }
    text
}

pub(crate) fn parse_length_val_simple(s: &str) -> Option<i32> {
    if let Some(LengthValue::Px(px)) = parse_length_value(Some(alloc::string::String::from(s))) {
        Some(px)
    } else {
        None
    }
}

// --- ビューポートヒント -----------------------------------------------------
// 置換要素 (textarea/img/button) の `width/height: N%` を解決する基準値。
// 本来 CSS の % は包含ブロック基準だが、置換要素の固有サイズ計算時点では
// 包含ブロック高さが未確定のため、レイアウトパス開始時に web_engine が
// 設定するビューポート (コンテンツ領域) サイズを近似基準として使う。
// これにより `<textarea style="width:100%;height:100%">` がウィンドウへ
// 自動フィットする。
pub(crate) use core::sync::atomic::{AtomicBool, AtomicI32, Ordering as AtomicOrdering};
pub static VIEWPORT_HINT_W: AtomicI32 = AtomicI32::new(800);
pub static VIEWPORT_HINT_H: AtomicI32 = AtomicI32::new(600);

/// `@container`（コンテナクエリ）評価時の**問い合わせコンテナ**の寸法。
///
/// `@media` はビューポート（上の `VIEWPORT_HINT_*`）を見ればよいが、
/// `@container` は要素ごとに基準が変わる。カスケードは要素を辿りながら
/// 走るので、レイアウト側が「いま評価している要素にとってのコンテナ」を
/// ここへ入れてからカスケードを呼ぶ。
///
/// 【重要】コンテナ寸法はレイアウトが決まるまで分からないため、
/// 初回カスケードでは前回のレイアウト結果（無ければビューポート幅）を
/// 使う近似になる。CSS 仕様どおりの厳密な 2 パスではないが、
/// 「解析時に静的評価して落とす」よりは実害が小さい
/// （`@media` の静的評価でページが白紙化した 2026-07-24 の失敗を参照）。
pub static CONTAINER_HINT_W: AtomicI32 = AtomicI32::new(0);
pub static CONTAINER_HINT_H: AtomicI32 = AtomicI32::new(0);

/// `@media (prefers-color-scheme: dark/light)` の判定に使うシステム設定のヒント。
/// 既定は light（false）。実際のシステムテーマ選択への連動は未配線で、
/// GUI 側が任意のタイミングで `store()` して更新できるようにするための土台。
pub static PREFERS_DARK: AtomicBool = AtomicBool::new(false);

/// `:target` 疑似クラスの判定に使う、現在の URL フラグメント（`#id` の `id` 部分、
/// 無ければ空文字）。ページ遷移/`navigate_to_fragment` 時に web_engine 側が更新する。
pub static CURRENT_TARGET_ID: spin::Mutex<alloc::string::String> =
    spin::Mutex::new(alloc::string::String::new());

/// `:focus-within` 疑似クラスの判定に使う、現在フォーカス中の要素自身とその祖先すべての
/// ノードポインタアドレス（`&Node as *const Node as usize`）集合。id を持たない要素も
/// 正しく判定できるよう、id ではなくノード実体の同一性で判定する（`:target` の
/// `CURRENT_TARGET_ID` と同じ「セレクタマッチング関数からグローバルを読む」方式）。
/// フォーカス変更のたびに web_engine 側が focused_id からルートまでの祖先パスを
/// 再計算して更新する。
pub static FOCUS_WITHIN_PTRS: spin::Mutex<alloc::collections::BTreeSet<usize>> =
    spin::Mutex::new(alloc::collections::BTreeSet::new());

/// `:lang()` 疑似クラスの判定に使う文書既定言語（`<html lang="...">` の値、小文字化済み）。
/// 要素自身に `lang` 属性が無い場合のフォールバックとして使う（`lang` は本来祖先から
/// 継承されるが、ここでは実用上ほとんどのケースをカバーする `<html>` の値のみを追跡する
/// 簡略実装。`CURRENT_TARGET_ID` と同じ「セレクタマッチング関数からグローバルを読む」方式）。
pub static DOCUMENT_LANG: spin::Mutex<alloc::string::String> =
    spin::Mutex::new(alloc::string::String::new());

// position:absolute の包含ブロック（最近傍 positioned 祖先の content box）。
// レイアウト降下中に positioned 要素が自分へ切替え、子孫の absolute がこれを基準に配置される。
/// 子の `height:%`（置換要素）の基準＝包含ブロックの**確定した** content 高。
/// -1 は「未確定」（仕様どおり `%` 高さは auto 扱い）。
/// 【2026-09-26】ブロック（明示高さ・aspect-ratio）と flex（明示高さ）が子を組む間だけ
/// 設定し、`PctBaseHGuard` の Drop で必ず戻す（途中 return があっても漏れない）。
pub(crate) static PCT_BASE_H: AtomicI32 = AtomicI32::new(-1);

/// `PCT_BASE_H` を一時的に差し替え、スコープを抜けると元へ戻す。
pub(crate) struct PctBaseHGuard(i32);

impl PctBaseHGuard {
    pub(crate) fn set(h: i32) -> Self {
        PctBaseHGuard(PCT_BASE_H.swap(h, AtomicOrdering::Relaxed))
    }
}

impl Drop for PctBaseHGuard {
    fn drop(&mut self) {
        PCT_BASE_H.store(self.0, AtomicOrdering::Relaxed);
    }
}

/// 次に組むブロックの content 高さを外から確定させる（-1 は無し）。`layout_block` の入口で
/// 取り出して消費する（子孫へは伝わらない）。絶対配置の `top`+`bottom` から決めた高さで、
/// 子の `height:%` もこれを基準に解決させるために使う（`tree.rs` の絶対配置）。
pub(crate) static FORCED_BLOCK_H: AtomicI32 = AtomicI32::new(-1);

pub(crate) static ABS_CB_X: AtomicI32 = AtomicI32::new(0);
pub(crate) static ABS_CB_Y: AtomicI32 = AtomicI32::new(0);
pub(crate) static ABS_CB_W: AtomicI32 = AtomicI32::new(800);
pub(crate) static ABS_CB_H: AtomicI32 = AtomicI32::new(600);
// position:fixed の基準（ビューポート原点）。
pub(crate) static VP_ORIGIN_X: AtomicI32 = AtomicI32::new(0);
pub(crate) static VP_ORIGIN_Y: AtomicI32 = AtomicI32::new(0);

pub(crate) fn abs_cb_get() -> (i32, i32, i32, i32) {
    (
        ABS_CB_X.load(AtomicOrdering::Relaxed),
        ABS_CB_Y.load(AtomicOrdering::Relaxed),
        ABS_CB_W.load(AtomicOrdering::Relaxed),
        ABS_CB_H.load(AtomicOrdering::Relaxed),
    )
}
pub(crate) fn abs_cb_set(x: i32, y: i32, w: i32, h: i32) {
    ABS_CB_X.store(x, AtomicOrdering::Relaxed);
    ABS_CB_Y.store(y, AtomicOrdering::Relaxed);
    ABS_CB_W.store(w, AtomicOrdering::Relaxed);
    ABS_CB_H.store(h, AtomicOrdering::Relaxed);
}
pub(crate) fn vp_origin_get() -> (i32, i32) {
    (
        VP_ORIGIN_X.load(AtomicOrdering::Relaxed),
        VP_ORIGIN_Y.load(AtomicOrdering::Relaxed),
    )
}

/// レイアウトパス開始前に web_engine から呼び、% 解決の基準サイズを設定する。
pub fn set_viewport_hint(w: i32, h: i32) {
    VIEWPORT_HINT_W.store(w.max(1), AtomicOrdering::Relaxed);
    VIEWPORT_HINT_H.store(h.max(1), AtomicOrdering::Relaxed);
}

/// px はそのまま、% は base 基準で解決する (auto 等は None)。
pub(crate) fn resolve_len_or_pct(s: &str, base: i32) -> Option<i32> {
    match parse_length_value(Some(alloc::string::String::from(s))) {
        Some(LengthValue::Px(px)) => Some(px),
        Some(LengthValue::Percent(pct)) => Some(round_f32_to_i32(base as f32 * pct)),
        _ => None,
    }
}

/// `a * num / den`（i64 で計算して丸める）。縦横比の換算用。den は 0 以外。
fn scale_dim(a: i32, num: i32, den: i32) -> i32 {
    ((a as i64 * num as i64 + den as i64 / 2) / den as i64) as i32
}

/// 置換要素の寸法（`%` はビューポート基準）。包含ブロック幅が分かる箇所では
/// `get_replaced_element_size_in` を使うこと。
pub(crate) fn get_replaced_element_size(node: &StyledNode) -> Option<(i32, i32)> {
    get_replaced_element_size_in(node, Some(VIEWPORT_HINT_W.load(AtomicOrdering::Relaxed)))
}

/// 置換要素（img/video/input 等）の寸法。
///
/// `pct_base_w` は `width`/`max-width` の `%` の基準（包含ブロックの content 幅）。
/// `None` は「基準が無い」（内在幅の計測中など）で、`%` 幅は auto 扱いになる。
///
/// 【2026-09-26 バグ修正】従来は `%` を常にビューポート基準で解決しており、
/// `img{width:100%}` が親の幅ではなく画面幅いっぱい（1280px）になっていた
/// （www.sugi-lab.net のギャラリー・研究紹介の画像）。併せて:
/// - 幅か高さの片方だけ指定されたら、自然サイズの縦横比でもう片方を決める
///   （従来は指定側だけ変わり画像が歪んだ）。
/// - `max-width`/`max-height` を比率を保って適用する（`img{max-width:100%}` は
///   レスポンシブ画像の定番）。
/// - `height` の `%` は包含ブロックの高さが確定していれば（`PCT_BASE_H`）それ基準、
///   未確定なら仕様どおり auto（従来はビューポート高さ基準で 800px 等になっていた）。
pub(crate) fn get_replaced_element_size_in(
    node: &StyledNode,
    pct_base_w: Option<i32>,
) -> Option<(i32, i32)> {
    let NodeType::Element {
        tag_name,
        attributes,
        ..
    } = &node.node.node_type
    else {
        return None;
    };
    // 置換要素として扱うタグ以外は、寸法を調べる前に抜ける（下の match の `_ => None`。
    // 【2026-10-18】全インライン要素で width/height/max-* の取得・解析をしてから None を返しており、
    // YouTube の操作部のレイアウト時間の大きな割合を占めていた）。
    if !matches!(tag_name.as_str(), "img" | "video" | "input" | "textarea" | "button") {
        return None;
    }

    let len_w = |v: &str| -> Option<i32> {
        match parse_length_value(Some(String::from(v))) {
            Some(LengthValue::Px(px)) => Some(px),
            Some(LengthValue::Percent(pct)) => pct_base_w.map(|b| round_f32_to_i32(b as f32 * pct)),
            _ => None,
        }
    };
    // `%` 高さは包含ブロックの高さが確定しているときだけ（`PCT_BASE_H`）。
    let base_h = PCT_BASE_H.load(AtomicOrdering::Relaxed);
    let len_h = |v: &str| -> Option<i32> {
        match parse_length_value(Some(String::from(v))) {
            Some(LengthValue::Px(px)) => Some(px),
            Some(LengthValue::Percent(pct)) if base_h >= 0 => {
                Some(round_f32_to_i32(base_h as f32 * pct))
            }
            _ => None,
        }
    };
    let css_w = len_value(node, "width").and_then(|v| len_w(&v));
    let css_h = len_value(node, "height").and_then(|v| len_h(&v));
    let max_w = len_value(node, "max-width").and_then(|v| len_w(&v));
    let max_h = len_value(node, "max-height").and_then(|v| len_h(&v));

    let attr_w = attributes
        .get("width")
        .and_then(|v| v.trim().parse::<i32>().ok());
    let attr_h = attributes
        .get("height")
        .and_then(|v| v.trim().parse::<i32>().ok());

    let target_w = css_w.or(attr_w);
    let target_h = css_h.or(attr_h);

    match tag_name.as_str() {
        "img" => {
            if let (Some(w), Some(h)) = (target_w, target_h) {
                return Some((w, h));
            }
            let mut resolved_w = 400;
            let mut resolved_h = 200;
            if let Some(src) = attributes.get("src") {
                // 【2026-08-05】まず登録済みの自然サイズを見る。
                //
                // 以前は `src` が `/` 始まり（ローカル FS）のときしか
                // 寸法を解決できず、ネットワーク画像は既定の 400×200 の
                // ままだった。取得完了時に
                // `register_image_natural_size` が登録するので、
                // 次のレイアウトでここが拾う。
                let registered = {
                    let cache = IMAGE_SIZE_CACHE.lock();
                    cache.as_ref().and_then(|c| c.get(src).copied())
                };
                if let Some((w, h)) = registered {
                    resolved_w = w;
                    resolved_h = h;
                } else if src.starts_with('/') {
                    {
                        let mut cache = IMAGE_SIZE_CACHE.lock();
                        if cache.is_none() {
                            *cache = Some(BTreeMap::new());
                        }
                    }
                    let mut cached = None;
                    if let Some(ref cache) = *IMAGE_SIZE_CACHE.lock() {
                        if let Some(&size) = cache.get(src) {
                            cached = Some(size);
                        }
                    }
                    if let Some((w, h)) = cached {
                        resolved_w = w;
                        resolved_h = h;
                    } else {
                        // 【2026-08-25 バグ修正】ここは **FS_LOCK を取らずに**
                        // FS を読んでいた。レイアウトはブラウザ本体スレッドで
                        // 走るが、画像・フォントのワーカースレッドは同時に
                        // `FS_LOCK` を取ってキャッシュを**書いて**いる。
                        // 書き込みの最中はビットマップとメタデータが
                        // 一時的に矛盾するので、素で読むと壊れた中身が返る。
                        //
                        // 読み取りの間だけ保持し、`IMAGE_SIZE_CACHE` を
                        // 触る前に手放す（ロックの入れ子を作らないため）。
                        let content = {
                            let _fs_guard = crate::kernel::fs::FS_LOCK.lock();
                            crate::kernel::fs::get_fs().read_file(src)
                        };
                        if let Some((_meta, content)) = content {
                            if let Some((w, h)) = get_image_size(&content) {
                                resolved_w = w;
                                resolved_h = h;
                                if let Some(ref mut cache) = *IMAGE_SIZE_CACHE.lock() {
                                    cache.insert(String::from(src), (w, h));
                                }
                            }
                        }
                    }
                }
            }
            // 片方だけ指定 → 自然サイズの比率でもう片方を決める。
            let (mut w, mut h) = match (target_w, target_h) {
                (Some(w), Some(h)) => (w, h),
                (Some(w), None) if resolved_w > 0 => (w, scale_dim(w, resolved_h, resolved_w)),
                (None, Some(h)) if resolved_h > 0 => (scale_dim(h, resolved_w, resolved_h), h),
                (w, h) => (w.unwrap_or(resolved_w), h.unwrap_or(resolved_h)),
            };
            // max-width / max-height（明示されていない側は比率を保って縮める）。
            if let Some(mw) = max_w {
                if mw >= 0 && w > mw {
                    if target_h.is_none() && w > 0 {
                        h = scale_dim(mw, h, w);
                    }
                    w = mw;
                }
            }
            if let Some(mh) = max_h {
                if mh >= 0 && h > mh {
                    if target_w.is_none() && h > 0 {
                        w = scale_dim(mh, w, h);
                    }
                    h = mh;
                }
            }
            Some((w.max(0), h.max(0)))
        }
        "video" => {
            let default_w = 400;
            let default_h = 240;
            Some((target_w.unwrap_or(default_w), target_h.unwrap_or(default_h)))
        }
        "input" => {
            let default_w = 300;
            let default_h = 32;
            Some((target_w.unwrap_or(default_w), target_h.unwrap_or(default_h)))
        }
        "textarea" => {
            let default_w = 400;
            let default_h = 200;
            Some((target_w.unwrap_or(default_w), target_h.unwrap_or(default_h)))
        }
        "button" => {
            let text = get_styled_node_text(node);
            let font_size = node
                .value("font-size")
                .and_then(|v| parse_font_size_u32(&v))
                .unwrap_or(16);
            let text_w =
                crate::kernel::vector_font::get_vector_string_width(&text, font_size) as i32;

            let class_val = attributes.get("class").map(|s| s.as_str()).unwrap_or("");
            let has_icon =
                class_val == "save_btn" || class_val == "load_btn" || class_val == "wrap_btn";
            let extra_w = if has_icon { 24 } else { 0 };
            let button_w = (text_w + 24 + extra_w).max(120);
            let button_h = 36;
            Some((target_w.unwrap_or(button_w), target_h.unwrap_or(button_h)))
        }
        _ => None,
    }
}

pub fn parse_line_height(val: Option<String>, font_size: u32) -> i32 {
    let Some(s) = val else {
        return (font_size as i32 + 4).max(12);
    };
    let t = s.trim();
    if t.is_empty() || t == "normal" {
        return (font_size as i32 + 4).max(12);
    }
    if let Some(num) = t.strip_suffix("px") {
        return num
            .trim()
            .parse::<i32>()
            .unwrap_or((font_size as i32 + 4).max(12));
    }
    if let Ok(factor) = t.parse::<f32>() {
        return (font_size as f32 * factor) as i32;
    }
    (font_size as i32 + 4).max(12)
}

/// `border-radius`の1角分の半径値を解決する。
/// `font_px` は要素自身の算出フォントサイズ（`em` 単位の計算に使用）。
pub fn resolve_border_radius_with_font(s: &str, container_w: i32, font_px: f32) -> i32 {
    let s = s.trim();
    if let Some(num) = s.strip_suffix("px") {
        return num.trim().parse::<f32>().map(|v| v as i32).unwrap_or(0);
    }
    if let Some(num) = s.strip_suffix('%') {
        return num
            .trim()
            .parse::<f32>()
            .map(|pct| ((pct / 100.0) * container_w as f32) as i32)
            .unwrap_or(0);
    }
    if let Some(num) = s.strip_suffix("rem") {
        return num.trim().parse::<f32>().map(|v| (v * 16.0) as i32).unwrap_or(0);
    }
    if let Some(num) = s.strip_suffix("em") {
        return num.trim().parse::<f32>().map(|v| (v * font_px) as i32).unwrap_or(0);
    }
    s.parse::<f32>().map(|v| v as i32).unwrap_or(0)
}

pub fn resolve_border_radius(s: &str, container_w: i32) -> i32 {
    resolve_border_radius_with_font(s, container_w, 16.0)
}

/// `top`/`left`/`right`/`bottom`/`inset` の長さ値をパースする。
/// `font_px` は要素自身のフォントサイズ（`em` 単位の計算に使用）。`rem` は 16px 固定基準。
pub fn parse_pos_len(v: &str, font_px: f32) -> Option<i32> {
    let s = v.trim();
    if let Some(num) = s.strip_suffix("px") {
        num.trim().parse::<f32>().map(|v| v as i32).ok()
    } else if let Some(num) = s.strip_suffix("rem") {
        num.trim().parse::<f32>().map(|v| (v * 16.0) as i32).ok()
    } else if let Some(num) = s.strip_suffix("em") {
        num.trim().parse::<f32>().map(|v| (v * font_px) as i32).ok()
    } else {
        s.parse::<i32>().ok()
    }
}