Gemini Compact Cache Response

// core/src/compact_cache.rs

use std::hash::{Hash, Hasher};
use rustc_hash::{FxHashMap, FxHasher};
use azul_css::{
    props::{
        basic::{
            color::ColorU,
            font::{StyleFontFamily, StyleFontFamilyVec},
            length::SizeMetric,
            pixel::{PixelValue, PixelValueWithAuto},
        },
        layout::*,
        property::{CssProperty, CssPropertyType},
        style::{
            StyleDirection, StyleFontStyle, StyleFontWeight, StyleTextAlign, StyleVerticalAlign,
            StyleVisibility, StyleWhiteSpace,
        },
    },
    AzString,
};
use crate::{
    dom::{NodeData, NodeId},
    styled_dom::StyledNodeState,
    prop_cache::CssPropertyCache,
};

// --- Tier 1: Bit-packed Enum Properties ---

/// Tier 1: All simple enum properties packed into a single u64.
/// 8 bytes per node.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[repr(transparent)]
pub struct SimpleEnumProps(u64);

// Bit layout for SimpleEnumProps (total bits used: 54)
const DISPLAY_SHIFT: u64 = 0;
const DISPLAY_MASK: u64 = 0x1F; // 5 bits for LayoutDisplay (up to 31 variants)

const POSITION_SHIFT: u64 = 5;
const POSITION_MASK: u64 = 0x7; // 3 bits for LayoutPosition (up to 7 variants)

const FLOAT_SHIFT: u64 = 8;
const FLOAT_MASK: u64 = 0x3; // 2 bits for LayoutFloat (up to 3 variants)

const OVERFLOW_X_SHIFT: u64 = 10;
const OVERFLOW_X_MASK: u64 = 0x7; // 3 bits for LayoutOverflow

const OVERFLOW_Y_SHIFT: u64 = 13;
const OVERFLOW_Y_MASK: u64 = 0x7; // 3 bits for LayoutOverflow

const FONT_WEIGHT_SHIFT: u64 = 16;
const FONT_WEIGHT_MASK: u64 = 0xF; // 4 bits for StyleFontWeight (up to 15 variants)

const FONT_STYLE_SHIFT: u64 = 20;
const FONT_STYLE_MASK: u64 = 0x3; // 2 bits for StyleFontStyle

const TEXT_ALIGN_SHIFT: u64 = 22;
const TEXT_ALIGN_MASK: u64 = 0x7; // 3 bits for StyleTextAlign

// ... Add other properties similarly ...
const FLEX_DIRECTION_SHIFT: u64 = 25;
const FLEX_DIRECTION_MASK: u64 = 0x3; // 2 bits for LayoutFlexDirection (4 variants)

const FLEX_WRAP_SHIFT: u64 = 27;
const FLEX_WRAP_MASK: u64 = 0x3; // 2 bits for LayoutFlexWrap (3 variants)

impl SimpleEnumProps {
    #[inline(always)]
    pub fn get_display(&self) -> LayoutDisplay {
        unsafe { std::mem::transmute(((self.0 >> DISPLAY_SHIFT) & DISPLAY_MASK) as u8) }
    }

    #[inline(always)]
    pub fn set_display(&mut self, val: LayoutDisplay) {
        self.0 &= !(DISPLAY_MASK << DISPLAY_SHIFT);
        self.0 |= (val as u64) << DISPLAY_SHIFT;
    }
    
    #[inline(always)]
    pub fn get_position(&self) -> LayoutPosition {
        unsafe { std::mem::transmute(((self.0 >> POSITION_SHIFT) & POSITION_MASK) as u8) }
    }

    #[inline(always)]
    pub fn set_position(&mut self, val: LayoutPosition) {
        self.0 &= !(POSITION_MASK << POSITION_SHIFT);
        self.0 |= (val as u64) << POSITION_SHIFT;
    }
    
    // ... Implement other getters/setters similarly ...
}


// --- Tier 2: Compact Numeric Properties ---

pub const SENTINEL: u32 = u32::MAX;

// Flags for CompactPixelValue (4 bits)
mod value_flags {
    pub const EXACT: u32 = 0;
    pub const AUTO: u32 = 1;
    pub const NONE: u32 = 2;
    pub const INITIAL: u32 = 3;
    pub const INHERIT: u32 = 4;
    pub const MIN_CONTENT: u32 = 5;
    pub const MAX_CONTENT: u32 = 6;
}

/// Tier 2: Represents a CSS dimension or numeric value in a compact u32.
/// Layout: [ 4-bit flags | 4-bit unit | 24-bit signed fixed-point value ]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(transparent)]
pub struct CompactPixelValue(u32);

impl CompactPixelValue {
    #[inline]
    pub fn is_sentinel(&self) -> bool {
        self.0 == SENTINEL
    }

    /// Decodes the compact u32 into a usable LayoutWidth, etc.
    /// This is a pure arithmetic function, extremely fast.
    #[inline(always)]
    pub fn decode_width(&self) -> LayoutWidth {
        let flags = (self.0 >> 28) & 0xF;
        match flags {
            value_flags::AUTO => LayoutWidth::Auto,
            value_flags::MIN_CONTENT => LayoutWidth::MinContent,
            value_flags::MAX_CONTENT => LayoutWidth::MaxContent,
            value_flags::EXACT => {
                let unit_bits = (self.0 >> 24) & 0xF;
                let unit: SizeMetric = unsafe { std::mem::transmute(unit_bits as u8) };
                
                // Sign-extend the 24-bit value to 32 bits
                let mut value_bits = self.0 & 0xFFFFFF;
                if (value_bits & 0x800000) != 0 {
                    value_bits |= 0xFF000000;
                }
                
                let value = value_bits as i32 as f32 / 1000.0;
                LayoutWidth::Px(PixelValue::from_metric(unit, value))
            },
            _ => LayoutWidth::Auto, // Fallback for Initial, Inherit, etc.
        }
    }

    // Add similar decoders for other types like LayoutHeight, PixelValue, etc.
}

/// Tier 2: Struct of Arrays for all compact numeric properties.
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct CompactDimensions {
    pub width: CompactPixelValue,
    pub height: CompactPixelValue,
    pub min_width: CompactPixelValue,
    pub min_height: CompactPixelValue,
    pub max_width: CompactPixelValue,
    pub max_height: CompactPixelValue,
    // Using individual fields is better than an array for struct-of-arrays
    pub padding_top: CompactPixelValue,
    pub padding_right: CompactPixelValue,
    pub padding_bottom: CompactPixelValue,
    pub padding_left: CompactPixelValue,
    pub margin_top: CompactPixelValue,
    pub margin_right: CompactPixelValue,
    pub margin_bottom: CompactPixelValue,
    pub margin_left: CompactPixelValue,
    // ... add all other Tier 2 properties ...
    
    // Special Tier 2 encodings
    pub text_color: u32, // Direct RGBA
    pub font_family_hash: u64,
    pub font_size: CompactPixelValue,
}


// --- Main Compact Cache Structure ---

#[derive(Debug, Clone, Default)]
pub struct CompactLayoutCache {
    /// Tier 1: Bit-packed enums. Very hot, small.
    pub tier1: Vec<SimpleEnumProps>,
    /// Tier 2: Compact numeric values. Hot, medium-sized.
    pub tier2: Vec<CompactDimensions>,
    /// Tier 3: Rare/complex properties. Cold, sparse.
    pub tier3: Vec<FxHashMap<CssPropertyType, CssProperty>>,
}

impl CompactLayoutCache {
    pub fn new(node_count: usize) -> Self {
        Self {
            tier1: vec
![SimpleEnumProps::default()
; node_count],
            tier2: vec
![CompactDimensions::default()
; node_count],
            tier3: vec
![FxHashMap::default()
; node_count],
        }
    }
}

// --- Builder Function ---

/// Builds the three-tier compact cache from the slow `CssPropertyCache`.
pub fn build_compact_cache(slow_cache: &CssPropertyCache, node_data: &[NodeData], styled_nodes: &[crate::styled_dom::StyledNode]) -> CompactLayoutCache {
    let node_count = slow_cache.node_count;
    let mut compact_cache = CompactLayoutCache::new(node_count);

    // This loop can be parallelized with Rayon
    for node_idx in 0..node_count {
        let node_id = NodeId::new(node_idx);
        let nd = &node_data[node_idx];
        let node_state = &styled_nodes[node_idx].styled_node_state;

        // Iterate through all property types and encode them
        for prop_type_val in 0..=CssPropertyType::StringSet as u8 {
            let prop_type: CssPropertyType = unsafe { std::mem::transmute(prop_type_val) };
            if let Some(prop) = slow_cache.get_property_slow(nd, &node_id, node_state, &prop_type) {
                encode_and_store(&mut compact_cache, node_idx, prop);
            }
        }
    }
    
    compact_cache
}

/// Encodes a single `CssProperty` and stores it in the correct tier.
fn encode_and_store(cache: &mut CompactLayoutCache, node_idx: usize, prop: &CssProperty) {
    
    fn encode_pixel_value_with_auto(val: &PixelValueWithAuto) -> CompactPixelValue {
        // ... implementation to encode PixelValueWithAuto to u32 ...
        // This is complex, so let's stub it for now with a sentinel.
        CompactPixelValue(SENTINEL)
    }

    match prop {
        // Tier 1 Encodings
        CssProperty::Display(v) => if let Some(e) = v.get_property() {
            cache.tier1[node_idx].set_display(*e);
        },
        CssProperty::Position(v) => if let Some(e) = v.get_property() {
            cache.tier1[node_idx].set_position(*e);
        },
        // ... other Tier 1 properties ...

        // Tier 2 Encodings
        CssProperty::Width(v) => {
            let encoded_val = match v {
                CssPropertyValue::Auto => value_flags::AUTO << 28,
                CssPropertyValue::Exact(LayoutWidth::Auto) => value_flags::AUTO << 28,
                CssPropertyValue::Exact(LayoutWidth::MinContent) => value_flags::MIN_CONTENT << 28,
                CssPropertyValue::Exact(LayoutWidth::MaxContent) => value_flags::MAX_CONTENT << 28,
                CssPropertyValue::Exact(LayoutWidth::Px(px)) => encode_pixel_value(px),
                CssPropertyValue::Exact(LayoutWidth::Calc(_)) => SENTINEL,
                _ => SENTINEL, // Handle Initial, Inherit, etc.
            };
            cache.tier2[node_idx].width = CompactPixelValue(encoded_val);
        },
        CssProperty::TextColor(v) => if let Some(c) = v.get_property() {
            cache.tier2[node_idx].text_color = c.inner.to_u32();
        },
        CssProperty::FontFamily(v) => if let Some(f) = v.get_property() {
            let mut hasher = FxHasher::default();
            f.hash(&mut hasher);
            cache.tier2[node_idx].font_family_hash = hasher.finish();
        },
        // ... other Tier 2 properties ...

        // Tier 3 Properties (overflow / complex)
        _ => {
            cache.tier3[node_idx].insert(prop.get_type(), prop.clone());
        }
    }
}

/// Helper to encode a PixelValue into a u32.
fn encode_pixel_value(px: &PixelValue) -> u32 {
    let value = (px.number.get() * 1000.0) as i32;
    // Check for overflow
    if value > 0x7FFFFF || value < -0x800000 {
        return SENTINEL;
    }

    let flags = value_flags::EXACT;
    let unit = px.metric as u32;
    let val_bits = (value as u32) & 0xFFFFFF;

    (flags << 28) | (unit << 24) | val_bits
}

// Add this to your use statements
use crate::compact_cache::CompactLayoutCache; 

// ... inside the CssPropertyCache struct ...
pub struct CssPropertyCache {
    // ... all the existing BTreeMap fields ...

    // This is the new, fast cache. It's an Option so it can be built on-demand.
    // Boxed to keep CssPropertyCache itself smaller on the stack.
    pub compact_cache: Option<Box<CompactLayoutCache>>, 
}

// In CssPropertyCache::empty
pub fn empty(node_count: usize) -> Self {
    Self {
        // ... initialize old fields ...
        compact_cache: None,
    }
}

// In CssPropertyCache::append
pub fn append(&mut self, other: &mut Self) {
    // ... append old fields ...
    
    // Invalidate compact cache - it must be rebuilt.
    self.compact_cache = None;
}

// In StyledDom::create (in styled_dom.rs)
// This is where you trigger the build process.
pub fn create(dom: &mut Dom, mut css: Css) -> Self {
    // ... existing logic to populate css_property_cache ...

    // NEW: Build the compact cache unconditionally or based on a threshold
    let new_compact_cache = crate::compact_cache::build_compact_cache(
        &css_property_cache, 
        compact_dom.node_data.as_ref().internal,
        &styled_nodes,
    );
    css_property_cache.compact_cache = Some(Box::new(new_compact_cache));

    // ... rest of the function ...
}

// layout/src/solver3/getters.rs

// Example: get_display_property
pub fn get_display_property(
    styled_dom: &StyledDom,
    dom_id: Option<NodeId>,
) -> MultiValue<LayoutDisplay> {
    let Some(id) = dom_id else {
        return MultiValue::Exact(LayoutDisplay::Inline);
    };

    // --- FAST PATH ---
    if let Some(compact_cache) = &styled_dom.css_property_cache.ptr.compact_cache {
        // Direct array lookup + bitwise decoding. Extremely fast.
        let display = compact_cache.tier1[id.index()].get_display();
        return MultiValue::Exact(display);
    }

    // --- SLOW PATH (fallback) ---
    let node_state = &styled_dom.styled_nodes.as_container()[id].styled_node_state;
    get_display_property_internal(styled_dom, id, node_state)
}

// Example: get_css_width
pub fn get_css_width(
    styled_dom: &StyledDom,
    node_id: NodeId,
    node_state: &StyledNodeState,
) -> MultiValue<LayoutWidth> {
    
    // --- FAST PATH ---
    if let Some(compact_cache) = &styled_dom.css_property_cache.ptr.compact_cache {
        let compact_val = &compact_cache.tier2[node_id.index()].width;
        if !compact_val.is_sentinel() {
            // Decode directly. Pure arithmetic, no memory access.
            return MultiValue::Exact(compact_val.decode_width());
        }
        // If it's a sentinel, it could be a complex value like calc().
        // We can check Tier 3 first for a slightly faster slow path.
        if let Some(prop) = compact_cache.tier3[node_id.index()].get(&CssPropertyType::Width) {
            if let CssProperty::Width(val) = prop {
                if let Some(exact_val) = val.get_property() {
                    return MultiValue::Exact(exact_val.clone());
                }
            }
        }
    }

    // --- SLOW PATH (fallback) ---
    let node_data = &styled_dom.node_data.as_container()[node_id];
    styled_dom.css_property_cache.ptr
        .get_width(node_data, &node_id, node_state)
        .and_then(|v| {
            if v.is_auto() { Some(MultiValue::Auto) }
            else { v.get_property().cloned().map(MultiValue::Exact) }
        })
        .unwrap_or(MultiValue::Auto)
}

// Example: How a font lookup might work (conceptual)
pub fn get_font_family_hash(
    styled_dom: &StyledDom,
    node_id: NodeId,
) -> Option<u64> {
    if let Some(compact_cache) = &styled_dom.css_property_cache.ptr.compact_cache {
        let hash = compact_cache.tier2[node_id.index()].font_family_hash;
        if hash != 0 {
            return Some(hash);
        }
    }
    None // Fallback to slow path if hash is 0 or cache doesn't exist
}

// ... apply this pattern to all other performance-critical getters ...