repose-ui 0.29.0

#![allow(non_snake_case)]

use std::collections::HashMap;
use std::rc::Rc;
use std::sync::Arc;

use repose_core::*;
use repose_tree::{NodeId, TreeStats, ViewTree};
use rustc_hash::FxHashMap;
use taffy::TaffyTree;

/// Measured text geometry feeding baseline alignment, by ViewTree NodeId.
/// `first`/`last` are real baselines (px from the text block top);
/// `content_h` is the un-stretched content height. Content height matters
/// because `Row` children default to `stretch`: layout height follows the
/// row, content height does not, and the grow pass must fit content rather
/// than stretch slack.
#[derive(Clone, Copy, Debug, Default)]
pub(crate) struct TextBaselines {
    pub(crate) first: f32,
    pub(crate) last: f32,
    pub(crate) content_h: f32,
}

pub(crate) struct ScopeLayoutTree {
    pub(crate) taffy: TaffyTree<NodeContext>,
    pub(crate) taffy_map: FxHashMap<NodeId, taffy::NodeId>,
    pub(crate) reverse_map: FxHashMap<taffy::NodeId, NodeId>,
    pub(crate) root_taffy_id: Option<taffy::NodeId>,
    pub(crate) last_constraints:
        Option<(taffy::Size<Option<f32>>, taffy::Size<taffy::AvailableSpace>)>,
    pub(crate) cached_size: Option<taffy::Size<f32>>,
    pub(crate) text_cache: FxHashMap<NodeId, TextLayout>,
    pub(crate) valid: bool,
    /// Measured text geometry by ViewTree NodeId, filled during measure.
    /// Consumed by the baseline-alignment post-pass (and grow pass).
    pub(crate) baseline_map: FxHashMap<NodeId, TextBaselines>,
    /// Vertical px shifts from baseline alignment, applied in
    /// `layout_for_node`. Overwritten every layout of this tree.
    pub(crate) baseline_shifts: FxHashMap<NodeId, f32>,
}

impl ScopeLayoutTree {
    pub(crate) fn new() -> Self {
        Self {
            taffy: TaffyTree::new(),
            taffy_map: FxHashMap::default(),
            reverse_map: FxHashMap::default(),
            root_taffy_id: None,
            last_constraints: None,
            cached_size: None,
            text_cache: FxHashMap::default(),
            valid: false,
            baseline_map: FxHashMap::default(),
            baseline_shifts: FxHashMap::default(),
        }
    }
}

pub struct LayoutEngine {
    pub(crate) tree: ViewTree,

    /// Root Taffy layout tree (inter-scope layout + non-scope nodes).
    pub(crate) taffy: TaffyTree<NodeContext>,

    pub(crate) taffy_map: FxHashMap<NodeId, taffy::NodeId>,

    /// Reverse map: root Taffy NodeId to ViewTree NodeId.
    pub(crate) reverse_map: FxHashMap<taffy::NodeId, NodeId>,

    /// Per-scope TaffyTrees for scope! macro isolation.
    pub(crate) scope_trees: HashMap<String, ScopeLayoutTree>,

    /// ViewTree NodeId -> scope key for scope boundary root nodes.
    pub(crate) scope_root_map: FxHashMap<NodeId, String>,

    /// ViewTree NodeId -> scope key for ALL nodes belonging to a scope.
    pub(crate) node_to_scope: FxHashMap<NodeId, String>,

    /// Cached text layouts for non-scope nodes (persists across frames).
    pub(crate) text_cache: FxHashMap<NodeId, TextLayout>,

    /// Measured text geometry by ViewTree NodeId, filled during measure.
    /// Consumed by the baseline-alignment post-pass (and grow pass).
    pub(crate) baseline_map: FxHashMap<NodeId, TextBaselines>,
    /// Vertical px shifts from baseline alignment, applied in
    /// `layout_for_node`. Overwritten every root layout.
    pub(crate) baseline_shifts: FxHashMap<NodeId, f32>,

    /// Last window size used for layout.
    pub(crate) last_size_px: Option<(u32, u32)>,

    /// Whether root Taffy has a valid computed layout for `last_size_px`.
    pub(crate) layout_valid: bool,

    /// Repaint-boundary cache (SceneNodes + hits + semantics).
    pub(crate) paint_cache: FxHashMap<NodeId, PaintCacheEntry>,

    /// Statistics from the last frame.
    pub stats: LayoutStats,

    /// Tracks the previously focused view ID to detect focus changes.
    pub(crate) prev_focused: Option<u64>,

    /// Callbacks registered via `on_focus_changed` modifier, keyed by view ID.
    pub(crate) focus_callbacks: FxHashMap<u64, Rc<dyn Fn(bool)>>,

    /// Last "locals" stamp used for layout decisions (density/text scale/dir).
    pub(crate) last_locals_stamp: Option<u64>,

    /// Stable, unique ViewId per ViewTree NodeId.
    pub(crate) view_ids: FxHashMap<NodeId, u64>,
    pub(crate) next_view_id: u64,

    /// Monotonic counter for graphics layer ids, assigned during paint.
    pub(crate) layer_id_counter: u32,

    /// Previous absolute rects for `on_globally_positioned` / `on_size_changed` callbacks.
    pub(crate) prev_observed_rects: FxHashMap<u64, repose_core::Rect>,

    /// Stack of active focus group IDs. When non-empty, newly created hit regions
    /// get `focus_group_id` set to the top of this stack. A focus group is entered
    /// when a node with `modifier.focus_group == true` is traversed.
    pub(crate) focus_group_stack: Vec<u64>,

    /// InteractionSources that should receive Focus/Unfocus for the current paint tree,
    /// keyed by view ID.
    pub(crate) focus_interaction_sources: FxHashMap<u64, InteractionSource>,
}

/// Statistics about layout performance.
#[derive(Clone, Debug, Default)]
pub struct LayoutStats {
    pub tree: TreeStats,

    /// Taffy nodes created this frame.
    pub taffy_created: usize,

    /// Taffy nodes reused this frame.
    pub taffy_reused: usize,

    /// Layout cache hits.
    pub layout_hits: usize,

    /// Layout cache misses.
    pub layout_misses: usize,

    /// Paint cache hits (repaint boundaries).
    pub paint_cache_hits: usize,

    /// Paint cache misses (repaint boundaries).
    pub paint_cache_misses: usize,

    /// Nodes skipped due to clip/viewport culling.
    pub paint_culled: usize,

    /// Total time for layout+paint (ms).
    pub layout_time_ms: f32,

    /// Total time spent in the paint pass only (ms).
    pub paint_time_ms: f32,
}

#[derive(Clone)]
pub(crate) struct PaintCacheEntry {
    pub(crate) subtree_hash: u64,
    pub(crate) stamp: u64,
    pub(crate) rect: repose_core::Rect,
    pub(crate) parent_offset_px: (f32, f32),
    pub(crate) sem_parent: Option<u64>,
    pub(crate) alpha_q: u8,
    pub(crate) nodes: Rc<Vec<SceneNode>>,
    pub(crate) hits: Rc<Vec<HitRegion>>,
    pub(crate) sems: Rc<Vec<SemNode>>,
}

/// Selects the intrinsic sizing mode for [`LayoutEngine::intrinsic_size`].
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum IntrinsicSizeMode {
    /// Smallest size at which the view's content does not overflow.
    MinContent,
    /// Largest size the view's content would take if unconstrained.
    MaxContent,
}

/// Context stored with each Taffy node.
#[derive(Clone)]
pub(crate) enum NodeContext {
    Text {
        text: String,
        font_dp: f32,
        soft_wrap: bool,
        max_lines: Option<usize>,
        overflow: TextOverflow,
        font_family: Option<&'static str>,
        font_weight: FontWeight,
        font_style: FontStyle,
        letter_spacing: f32,
        line_height: f32,
        font_variation_settings: Option<Arc<str>>,
        annotations: Option<Arc<[TextSpan]>>,
    },
    Container,
    ScrollContainer,
    TextInput {
        multiline: bool,
    },
}

#[derive(Clone)]
pub(crate) struct TextLayout {
    pub(crate) lines: Vec<String>,
    /// Byte ranges into the original text for each line (used for annotation splitting).
    pub(crate) line_ranges: Vec<(usize, usize)>,
    pub(crate) size_px: f32,
    pub(crate) line_h_px: f32,
    /// Pre-measured width per line, in the same order as `lines`.
    pub(crate) line_widths: Vec<f32>,
    /// Per-line height in px (accounts for larger annotated font sizes, baseline shifts, stroke).
    /// Uniform fallback is `line_h_px` when empty.
    pub(crate) line_heights: Vec<f32>,
}