Layout Engine

pub struct LayoutEngine {
    pub text_engine: TextLayoutEngine,
}

impl LayoutEngine {
    pub fn compute_layout(
        &mut self,
        element: &Element,
        viewport_width: f32,
        viewport_height: Option<f32>,
        default_font_family: Option<&str>,
    ) -> Result<LayoutResult, LayoutError> {
        let mut taffy: TaffyTree<NodeContext> = TaffyTree::new();
        let mut node_data = HashMap::new();

        // Build tree recursively
        let root = self.build_node(&mut taffy, &mut node_data, element, default_font_family)?;

        // ... compute layout
    }
}

fn dimension_to_taffy(dim: &Option<Dimension>) -> taffy::Dimension {
    match dim {
        None => taffy::Dimension::auto(),
        Some(Dimension::Px(px)) => taffy::Dimension::length(*px),
        Some(Dimension::Percent(s)) => {
            let pct = s.trim_end_matches('%').parse::<f32>().unwrap_or(0.0);
            taffy::Dimension::percent(pct / 100.0)
        }
    }
}

fn spacing_to_taffy_rect(spacing: &Option<Spacing>) -> Rect<LengthPercentageAuto> {
    match spacing {
        None => Rect {
            top: LengthPercentageAuto::length(0.0),
            right: LengthPercentageAuto::length(0.0),
            bottom: LengthPercentageAuto::length(0.0),
            left: LengthPercentageAuto::length(0.0),
        },
        Some(s) => {
            let [top, right, bottom, left] = s.to_edges();
            Rect {
                top: LengthPercentageAuto::length(top),
                right: LengthPercentageAuto::length(right),
                bottom: LengthPercentageAuto::length(bottom),
                left: LengthPercentageAuto::length(left),
            }
        }
    }
}

pub enum NodeContext {
    /// Text node that needs Parley for measurement
    Text(TextContext),
    /// Image with intrinsic dimensions
    Image { width: f32, height: f32 },
}

pub struct TextContext {
    pub content: String,
    pub font_family: Option<String>,
    pub font_size: f32,
    pub font_weight: u16,
    pub line_height: f32,
    pub letter_spacing: f32,
}

fn measure_function(
    known_dimensions: Size<Option<f32>>,
    available_space: Size<AvailableSpace>,
    node_context: Option<&mut NodeContext>,
    text_engine: &mut TextLayoutEngine,
) -> Size<f32> {
    match node_context {
        Some(NodeContext::Text(ctx)) => {
            // Use known dimensions if available
            if let (Some(width), Some(height)) = (known_dimensions.width, known_dimensions.height) {
                return Size { width, height };
            }

            // Determine available width for text wrapping
            let available_width = match available_space.width {
                AvailableSpace::Definite(w) => Some(w),
                AvailableSpace::MinContent => Some(0.0),
                AvailableSpace::MaxContent => None,
            };

            // Measure text using the text engine
            text_engine.measure(&ctx.content, ctx.font_size, available_width)
        }
        Some(NodeContext::Image { width, height }) => {
            // Use intrinsic dimensions, respecting any known constraints
            Size {
                width: known_dimensions.width.unwrap_or(*width),
                height: known_dimensions.height.unwrap_or(*height),
            }
        }
        None => Size::ZERO,
    }
}

let available_space = Size {
    width: AvailableSpace::Definite(viewport_width),
    height: viewport_height
        .map(AvailableSpace::Definite)
        .unwrap_or(AvailableSpace::MaxContent),
};

taffy.compute_layout_with_measure(
    root,
    available_space,
    |known_dimensions, available_space, _node_id, node_context, _style| {
        measure_function(known_dimensions, available_space, node_context, text_engine)
    },
)?;

pub struct LayoutResult {
    /// The Taffy tree with computed layout
    pub taffy: TaffyTree<NodeContext>,
    /// Root node ID
    pub root: NodeId,
    /// Map from Taffy NodeId to original Element reference index
    pub node_data: HashMap<NodeId, NodeData>,
}

pub struct NodeData {
    /// The element type for rendering
    pub element_type: ElementType,
    /// Visual style for rendering
    pub visual: VisualStyle,
}

pub struct VisualStyle {
    pub background_color: Option<Color>,
    pub border_width: f32,
    pub border_color: Option<Color>,
    pub border_radius: [f32; 4],
    pub opacity: f32,
}

let layout = result.taffy.layout(node_id).unwrap();

println!("Position: ({}, {})", layout.location.x, layout.location.y);
println!("Size: {} x {}", layout.size.width, layout.size.height);
println!("Padding: {:?}", layout.padding);
println!("Border: {:?}", layout.border);