Intrinsic Sizing

pub struct SizeConstraints {
    pub min: Size,           // Minimum usable size
    pub preferred: Size,     // Ideal size for content
    pub max: Option<Size>,   // Maximum useful size (None = unbounded)
}

pub trait MeasurableWidget {
    /// Measure the widget given available space.
    fn measure(&self, available: Size) -> SizeConstraints {
        SizeConstraints::ZERO // Default: fill available
    }
 
    /// Does this widget have content-dependent sizing?
    fn has_intrinsic_size(&self) -> bool {
        false // Default: no
    }
}

use ftui_core::geometry::Size;
use ftui_widgets::{MeasurableWidget, SizeConstraints};
 
struct Label {
    text: String,
}
 
impl MeasurableWidget for Label {
    fn measure(&self, _available: Size) -> SizeConstraints {
        let width = self.text.len() as u16;
        SizeConstraints {
            min: Size::new(1, 1),           // At least show something
            preferred: Size::new(width, 1), // Full text on one line
            max: Some(Size::new(width, 1)), // No benefit from extra space
        }
    }
 
    fn has_intrinsic_size(&self) -> bool {
        true
    }
}

impl MeasurableWidget for Paragraph {
    fn measure(&self, available: Size) -> SizeConstraints {
        // Calculate wrapped line count at available width
        let lines = self.wrap_lines(available.width);
        let max_line_width = lines.iter().map(|l| l.len()).max().unwrap_or(0) as u16;
        let height = lines.len() as u16;
 
        SizeConstraints {
            min: Size::new(1, 1),
            preferred: Size::new(max_line_width, height),
            max: None, // Can use extra space for padding
        }
    }
 
    fn has_intrinsic_size(&self) -> bool {
        true
    }
}

impl MeasurableWidget for HorizontalStack {
    fn measure(&self, available: Size) -> SizeConstraints {
        let mut total_width = 0u16;
        let mut max_height = 0u16;
        let mut min_width = 0u16;
        let mut min_height = 0u16;
 
        for child in &self.children {
            let c = child.measure(available);
            total_width = total_width.saturating_add(c.preferred.width);
            max_height = max_height.max(c.preferred.height);
            min_width = min_width.saturating_add(c.min.width);
            min_height = min_height.max(c.min.height);
        }
 
        SizeConstraints {
            min: Size::new(min_width, min_height),
            preferred: Size::new(total_width, max_height),
            max: None,
        }
    }
 
    fn has_intrinsic_size(&self) -> bool {
        self.children.iter().any(|c| c.has_intrinsic_size())
    }
}

// Old approach: fixed widths
let chunks = Flex::horizontal()
    .constraints([
        Constraint::Fixed(20),  // Sidebar always 20 cols
        Constraint::Fill,       // Content fills rest
    ])
    .split(area);

// New approach: fit to content
let chunks = Flex::horizontal()
    .constraints([
        Constraint::FitContent, // Sidebar fits its content
        Constraint::Fill,       // Content fills rest
    ])
    .split(area);
 
// The layout system calls sidebar.measure() to determine width

impl MeasurableWidget for AdaptiveSidebar {
    fn measure(&self, available: Size) -> SizeConstraints {
        if available.width < 60 {
            // Icon-only mode
            SizeConstraints::exact(Size::new(4, available.height))
        } else {
            // Full labels
            SizeConstraints {
                min: Size::new(4, 1),
                preferred: Size::new(20, available.height),
                max: Some(Size::new(30, available.height)),
            }
        }
    }
}

fn layout_cards(area: Rect) -> Vec<Rect> {
    if area.width >= 60 {
        // Side-by-side
        Flex::horizontal()
            .constraints([Constraint::FitContent, Constraint::FitContent])
            .split(area)
    } else {
        // Stacked
        Flex::vertical()
            .constraints([Constraint::FitContent, Constraint::FitContent])
            .split(area)
    }
}

#[test]
fn widget_measure_invariants() {
    let widget = MyWidget::new("content");
    let available = Size::new(100, 50);
    let c = widget.measure(available);
 
    // Invariant: min <= preferred <= max
    assert!(c.min.width <= c.preferred.width);
    assert!(c.min.height <= c.preferred.height);
    if let Some(max) = c.max {
        assert!(c.preferred.width <= max.width);
        assert!(c.preferred.height <= max.height);
    }
}
 
#[test]
fn widget_measure_is_pure() {
    let widget = MyWidget::new("content");
    let available = Size::new(100, 50);
 
    let c1 = widget.measure(available);
    let c2 = widget.measure(available);
 
    assert_eq!(c1, c2, "measure() must be pure");
}
 
#[test]
fn widget_min_is_constant() {
    let widget = MyWidget::new("content");
 
    let c1 = widget.measure(Size::new(100, 50));
    let c2 = widget.measure(Size::new(200, 100));
 
    assert_eq!(c1.min, c2.min, "min should not depend on available");
}