mtk-rs 0.1.0-beta.4

use crate::TextStyle;
use crate::colors::Color;
use parley::style::{FontStyle, LineHeight, StyleProperty};
use parley::{
    AlignmentOptions, BreakReason, Cluster, ClusterSide, Cursor, FontContext, LayoutContext,
};
use std::ops::Range;
use std::sync::Arc;
use std::sync::Mutex;
use swash::scale::ScaleContext;

/// Visual styling applied to a specific sub-range of text in a rich text layout.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SpanStyle {
    pub color: Option<Color>,
    pub font_weight: Option<parley::style::FontWeight>,
    pub font_style: Option<FontStyle>,
    pub font_size: Option<f32>,
    pub underline: bool,
    pub strikethrough: bool,
}

impl SpanStyle {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn color(mut self, color: Color) -> Self {
        self.color = Some(color);
        self
    }

    pub fn bold(mut self) -> Self {
        self.font_weight = Some(parley::style::FontWeight::BOLD);
        self
    }

    pub fn weight(mut self, weight: parley::style::FontWeight) -> Self {
        self.font_weight = Some(weight);
        self
    }

    pub fn italic(mut self) -> Self {
        self.font_style = Some(FontStyle::Italic);
        self
    }

    pub fn font_style(mut self, style: FontStyle) -> Self {
        self.font_style = Some(style);
        self
    }

    pub fn font_size(mut self, size: f32) -> Self {
        self.font_size = Some(size);
        self
    }

    pub fn underline(mut self, underline: bool) -> Self {
        self.underline = underline;
        self
    }

    pub fn strikethrough(mut self, strikethrough: bool) -> Self {
        self.strikethrough = strikethrough;
        self
    }

    /// Overlays another `SpanStyle` onto `self`, preferring non-None and true values from `other`.
    pub fn merge(&self, other: &SpanStyle) -> SpanStyle {
        SpanStyle {
            color: other.color.or(self.color),
            font_weight: other.font_weight.or(self.font_weight),
            font_style: other.font_style.or(self.font_style),
            font_size: other.font_size.or(self.font_size),
            underline: other.underline || self.underline,
            strikethrough: other.strikethrough || self.strikethrough,
        }
    }

    /// Returns `true` if applying this style could alter character advances, line breaks, or text bounds.
    pub fn affects_geometry(&self) -> bool {
        self.font_weight.is_some() || self.font_style.is_some() || self.font_size.is_some()
    }
}

/// A styled range of text with an optional identifier tag for interactivity.
#[derive(Clone, Debug, PartialEq)]
pub struct TextSpan<Id = ()> {
    pub range: Range<usize>,
    pub style: SpanStyle,
    pub hover_style: Option<SpanStyle>,
    pub id: Option<Id>,
}

impl<Id> TextSpan<Id> {
    pub fn new(range: Range<usize>) -> Self {
        Self {
            range,
            style: SpanStyle::default(),
            hover_style: None,
            id: None,
        }
    }

    pub fn id(mut self, id: Id) -> Self {
        self.id = Some(id);
        self
    }

    pub fn color(mut self, color: Color) -> Self {
        self.style.color = Some(color);
        self
    }

    pub fn bold(mut self) -> Self {
        self.style.font_weight = Some(parley::style::FontWeight::BOLD);
        self
    }

    pub fn weight(mut self, weight: parley::style::FontWeight) -> Self {
        self.style.font_weight = Some(weight);
        self
    }

    pub fn italic(mut self) -> Self {
        self.style.font_style = Some(FontStyle::Italic);
        self
    }

    pub fn font_style(mut self, style: FontStyle) -> Self {
        self.style.font_style = Some(style);
        self
    }

    pub fn font_size(mut self, size: f32) -> Self {
        self.style.font_size = Some(size);
        self
    }

    pub fn underline(mut self) -> Self {
        self.style.underline = true;
        self
    }

    pub fn strikethrough(mut self) -> Self {
        self.style.strikethrough = true;
        self
    }

    pub fn style(mut self, style: SpanStyle) -> Self {
        self.style = style;
        self
    }

    /// Configures a full hover style to apply when the mouse cursor hovers over this span.
    pub fn hover_style(mut self, style: SpanStyle) -> Self {
        self.hover_style = Some(style);
        self
    }

    /// Convenience builder to override text color on hover.
    pub fn hover_color(mut self, color: Color) -> Self {
        let mut h = self.hover_style.unwrap_or_default();
        h.color = Some(color);
        self.hover_style = Some(h);
        self
    }

    /// Convenience builder to add an underline on hover.
    pub fn hover_underline(mut self) -> Self {
        let mut h = self.hover_style.unwrap_or_default();
        h.underline = true;
        self.hover_style = Some(h);
        self
    }

    /// Convenience builder to make text bold on hover.
    pub fn hover_bold(mut self) -> Self {
        let mut h = self.hover_style.unwrap_or_default();
        h.font_weight = Some(parley::style::FontWeight::BOLD);
        self.hover_style = Some(h);
        self
    }

    /// Convenience builder to set a specific font weight on hover.
    pub fn hover_weight(mut self, weight: parley::style::FontWeight) -> Self {
        let mut h = self.hover_style.unwrap_or_default();
        h.font_weight = Some(weight);
        self.hover_style = Some(h);
        self
    }

    /// Convenience builder to make text italic on hover.
    pub fn hover_italic(mut self) -> Self {
        let mut h = self.hover_style.unwrap_or_default();
        h.font_style = Some(FontStyle::Italic);
        self.hover_style = Some(h);
        self
    }

    /// Convenience builder to set font style on hover.
    pub fn hover_font_style(mut self, style: FontStyle) -> Self {
        let mut h = self.hover_style.unwrap_or_default();
        h.font_style = Some(style);
        self.hover_style = Some(h);
        self
    }

    /// Convenience builder to set font size on hover.
    pub fn hover_font_size(mut self, size: f32) -> Self {
        let mut h = self.hover_style.unwrap_or_default();
        h.font_size = Some(size);
        self.hover_style = Some(h);
        self
    }

    /// Convenience builder to add strikethrough on hover.
    pub fn hover_strikethrough(mut self) -> Self {
        let mut h = self.hover_style.unwrap_or_default();
        h.strikethrough = true;
        self.hover_style = Some(h);
        self
    }

    /// Converts this span to an untyped span for layout and rendering.
    pub fn to_untyped(&self) -> TextSpan<()> {
        TextSpan {
            range: self.range.clone(),
            style: self.style.clone(),
            hover_style: self.hover_style.clone(),
            id: None,
        }
    }
}

pub(crate) fn hash_spans(spans: &[TextSpan<()>]) -> u64 {
    if spans.is_empty() {
        return 0;
    }
    use std::hash::{Hash, Hasher};
    let mut hasher = std::collections::hash_map::DefaultHasher::new();
    for span in spans {
        span.range.start.hash(&mut hasher);
        span.range.end.hash(&mut hasher);
        if let Some(c) = span.style.color {
            c.as_u32().hash(&mut hasher);
        }
        if let Some(w) = span.style.font_weight {
            w.value().to_bits().hash(&mut hasher);
        }
        if let Some(s) = span.style.font_style {
            match s {
                FontStyle::Normal => 0u8.hash(&mut hasher),
                FontStyle::Italic => 1u8.hash(&mut hasher),
                FontStyle::Oblique(_) => 2u8.hash(&mut hasher),
            }
        }
        if let Some(sz) = span.style.font_size {
            sz.to_bits().hash(&mut hasher);
        }
        span.style.underline.hash(&mut hasher);
        span.style.strikethrough.hash(&mut hasher);
    }
    hasher.finish()
}

use hashbrown::Equivalent;

#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct TextLayoutCacheKey {
    pub text: String,
    pub font_size_bits: u32,
    pub font_family: String,
    pub font_weight_bits: u32,
    pub font_style: u8,
    pub color_u32: u32,
    pub wrap: bool,
    pub strikethrough: bool,
    pub underline: bool,
    pub selection: Option<(usize, usize)>,
    pub preedit_range: Option<(usize, usize)>,
    pub inner_w_bits: u32,
    pub spans_hash: u64,
}

#[derive(Copy, Clone, Debug)]
pub struct TextLayoutLookupKey<'a> {
    pub text: &'a str,
    pub font_size_bits: u32,
    pub font_family: &'a str,
    pub font_weight_bits: u32,
    pub font_style: u8,
    pub color_u32: u32,
    pub wrap: bool,
    pub strikethrough: bool,
    pub underline: bool,
    pub selection: Option<(usize, usize)>,
    pub preedit_range: Option<(usize, usize)>,
    pub inner_w_bits: u32,
    pub spans_hash: u64,
}

impl<'a> std::hash::Hash for TextLayoutLookupKey<'a> {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.text.hash(state);
        self.font_size_bits.hash(state);
        self.font_family.hash(state);
        self.font_weight_bits.hash(state);
        self.font_style.hash(state);
        self.color_u32.hash(state);
        self.wrap.hash(state);
        self.strikethrough.hash(state);
        self.underline.hash(state);
        self.selection.hash(state);
        self.preedit_range.hash(state);
        self.inner_w_bits.hash(state);
        self.spans_hash.hash(state);
    }
}

impl<'a> Equivalent<TextLayoutCacheKey> for TextLayoutLookupKey<'a> {
    fn equivalent(&self, key: &TextLayoutCacheKey) -> bool {
        self.text == key.text
            && self.font_size_bits == key.font_size_bits
            && self.font_family == key.font_family
            && self.font_weight_bits == key.font_weight_bits
            && self.font_style == key.font_style
            && self.color_u32 == key.color_u32
            && self.wrap == key.wrap
            && self.strikethrough == key.strikethrough
            && self.underline == key.underline
            && self.selection == key.selection
            && self.preedit_range == key.preedit_range
            && self.inner_w_bits == key.inner_w_bits
            && self.spans_hash == key.spans_hash
    }
}

impl<'a> TextLayoutLookupKey<'a> {
    pub fn to_cache_key(&self) -> TextLayoutCacheKey {
        TextLayoutCacheKey {
            text: self.text.to_string(),
            font_size_bits: self.font_size_bits,
            font_family: self.font_family.to_string(),
            font_weight_bits: self.font_weight_bits,
            font_style: self.font_style,
            color_u32: self.color_u32,
            wrap: self.wrap,
            strikethrough: self.strikethrough,
            underline: self.underline,
            selection: self.selection,
            preedit_range: self.preedit_range,
            inner_w_bits: self.inner_w_bits,
            spans_hash: self.spans_hash,
        }
    }
}

pub struct TextLayoutCacheEntry {
    pub layout: parley::Layout<Color>,
    pub actual_text_width: f32,
    pub actual_text_height: f32,
}

/// Holds the shared text rendering state.
pub struct TextContext {
    pub font_cx: FontContext,
    pub layout_cx: LayoutContext<Color>,
    pub scale_cx: ScaleContext,
    /// Current active generation of cached layouts.
    pub current_cache: hashbrown::HashMap<TextLayoutCacheKey, Arc<TextLayoutCacheEntry>>,
    /// Previous generation of cached layouts. Items queried here are promoted to `current_cache`.
    pub previous_cache: hashbrown::HashMap<TextLayoutCacheKey, Arc<TextLayoutCacheEntry>>,
    /// Maximum capacity per generation before aging out `previous_cache`.
    pub generation_capacity: usize,
}

impl TextContext {
    pub fn new() -> Self {
        Self {
            font_cx: FontContext::new(),
            layout_cx: LayoutContext::new(),
            scale_cx: ScaleContext::new(),
            current_cache: hashbrown::HashMap::new(),
            previous_cache: hashbrown::HashMap::new(),
            generation_capacity: 4096,
        }
    }

    /// Registers raw font bytes (.ttf or .otf) into the Parley font collection.
    pub fn register_fonts(&mut self, font_data: Vec<u8>) {
        self.font_cx
            .collection
            .register_fonts(font_data.into(), None);
        self.clear_cache();
    }

    /// Clears both generations of the layout cache.
    pub fn clear_cache(&mut self) {
        self.current_cache.clear();
        self.previous_cache.clear();
    }

    /// Returns the total number of cached layout entries across both generations.
    pub fn cached_layout_count(&self) -> usize {
        self.current_cache.len() + self.previous_cache.len()
    }

    /// Loads and registers a font file from disk.
    pub fn register_font_file(&mut self, path: impl AsRef<std::path::Path>) -> std::io::Result<()> {
        let data = std::fs::read(path)?;
        self.register_fonts(data);
        Ok(())
    }

    pub fn get_or_create_layout(
        &mut self,
        text: &str,
        text_style: &TextStyle,
        avail_w: f32,
        selection: Option<(usize, usize)>,
        preedit_range: Option<(usize, usize)>,
        spans: &[TextSpan<()>],
    ) -> Arc<TextLayoutCacheEntry> {
        let font_style_u8 = match text_style.font_style {
            FontStyle::Normal => 0,
            FontStyle::Italic => 1,
            FontStyle::Oblique(_) => 2,
        };

        let inner_w_bits = if text_style.wrap && avail_w.is_finite() && avail_w > 0.0 {
            avail_w.to_bits()
        } else {
            u32::MAX
        };

        let spans_hash = hash_spans(spans);

        let lookup_key = TextLayoutLookupKey {
            text,
            font_size_bits: text_style.font_size.to_bits(),
            font_family: &text_style.font_family,
            font_weight_bits: text_style.font_weight.value().to_bits(),
            font_style: font_style_u8,
            color_u32: text_style.color.as_u32(),
            wrap: text_style.wrap,
            strikethrough: text_style.strikethrough,
            underline: text_style.underline,
            selection,
            preedit_range,
            inner_w_bits,
            spans_hash,
        };

        // 1. Check current active generation (fast path, zero allocation)
        if let Some(entry) = self.current_cache.get(&lookup_key) {
            return Arc::clone(entry);
        }

        // 2. Check previous generation; if found, promote to current generation (zero allocation)
        if let Some((prev_key, entry)) = self.previous_cache.remove_entry(&lookup_key) {
            let cloned_entry = Arc::clone(&entry);
            if self.current_cache.len() >= self.generation_capacity {
                self.previous_cache = std::mem::take(&mut self.current_cache);
            }
            self.current_cache.insert(prev_key, entry);
            return cloned_entry;
        }

        let display_scale = 1.0;
        let quantize = true;

        let mut builder =
            self.layout_cx
                .ranged_builder(&mut self.font_cx, text, display_scale, quantize);

        builder.push_default(StyleProperty::Brush(text_style.color));
        builder.push_default(StyleProperty::FontSize(text_style.font_size));
        builder.push_default(StyleProperty::LineHeight(LineHeight::FontSizeRelative(
            text_style.line_height.resolve(),
        )));
        builder.push_default(StyleProperty::FontWeight(text_style.font_weight));
        builder.push_default(StyleProperty::FontStyle(text_style.font_style));
        builder.push_default(parley::style::FontFamily::from(
            text_style.font_family.as_ref(),
        ));
        if text_style.wrap {
            builder.push_default(StyleProperty::OverflowWrap(text_style.overflow_wrap));
        }

        if text_style.strikethrough {
            builder.push_default(StyleProperty::Strikethrough(true));
        }

        if text_style.underline {
            builder.push_default(StyleProperty::Underline(true));
        }

        if let Some((start, end)) = preedit_range {
            builder.push(StyleProperty::Underline(true), start..end);
        }

        if let Some((start, end)) = selection {
            builder.push(StyleProperty::Brush(text_style.selection_color), start..end);
        }

        for span in spans {
            let start = span.range.start.min(text.len());
            let end = span.range.end.min(text.len());
            if start >= end {
                continue;
            }

            if let Some(color) = span.style.color {
                builder.push(StyleProperty::Brush(color), start..end);
            }
            if let Some(weight) = span.style.font_weight {
                builder.push(StyleProperty::FontWeight(weight), start..end);
            }
            if let Some(style) = span.style.font_style {
                builder.push(StyleProperty::FontStyle(style), start..end);
            }
            if let Some(size) = span.style.font_size {
                builder.push(StyleProperty::FontSize(size), start..end);
            }
            if span.style.underline {
                builder.push(StyleProperty::Underline(true), start..end);
            }
            if span.style.strikethrough {
                builder.push(StyleProperty::Strikethrough(true), start..end);
            }
        }

        let mut layout = builder.build(text);

        let max_advance = if text_style.wrap && avail_w.is_finite() && avail_w > 0.0 {
            Some(avail_w + 0.5)
        } else {
            None
        };
        layout.break_all_lines(max_advance);
        let actual_text_width = layout.width();
        let actual_text_height = layout.height();

        let entry = Arc::new(TextLayoutCacheEntry {
            layout,
            actual_text_width,
            actual_text_height,
        });

        if self.current_cache.len() >= self.generation_capacity {
            self.previous_cache = std::mem::take(&mut self.current_cache);
        }

        self.current_cache
            .insert(lookup_key.to_cache_key(), Arc::clone(&entry));
        entry
    }
}

pub type SharedTextContext = Arc<Mutex<TextContext>>;

pub fn measure_text(
    text: &str,
    text_style: &TextStyle,
    avail_w: f32,
    _avail_h: f32,
    shared_ctx: &SharedTextContext,
    spans: &[TextSpan<()>],
) -> TextComputedOutput {
    let mut ctx_guard = shared_ctx.lock().unwrap();
    let entry = ctx_guard.get_or_create_layout(text, text_style, avail_w, None, None, spans);

    TextComputedOutput {
        computed_width: entry.actual_text_width.ceil(),
        computed_height: entry.actual_text_height.ceil(),
        baseline_offset: entry
            .layout
            .lines()
            .next()
            .map(|l| l.metrics().ascent)
            .unwrap_or(text_style.font_size),
    }
}

pub fn hit_test_text(
    text: &str,
    text_style: &TextStyle,
    avail_w: f32,
    avail_h: f32,
    x: f32,
    y: f32,
    shared_ctx: &SharedTextContext,
    spans: &[TextSpan<()>],
) -> usize {
    let mut ctx_guard = shared_ctx.lock().unwrap();
    let entry = ctx_guard.get_or_create_layout(text, text_style, avail_w, None, None, spans);
    let layout = &entry.layout;
    let actual_text_width = entry.actual_text_width;
    let actual_text_height = entry.actual_text_height;

    let horizontal_offset = match text_style.alignment {
        parley::layout::Alignment::Center => {
            if avail_w.is_finite() && avail_w > 0.0 {
                ((avail_w - actual_text_width) / 2.0).max(0.0)
            } else {
                0.0
            }
        }
        parley::layout::Alignment::End | parley::layout::Alignment::Right => {
            if avail_w.is_finite() && avail_w > 0.0 {
                (avail_w - actual_text_width).max(0.0)
            } else {
                0.0
            }
        }
        _ => 0.0,
    };

    let vertical_offset = match text_style.vertical_alignment {
        crate::style::VerticalAlignment::Top => 0.0,
        crate::style::VerticalAlignment::Center => {
            if avail_h.is_finite() && avail_h > 0.0 {
                ((avail_h - actual_text_height) / 2.0).max(0.0)
            } else {
                0.0
            }
        }
        crate::style::VerticalAlignment::Bottom => {
            if avail_h.is_finite() && avail_h > 0.0 {
                (avail_h - actual_text_height).max(0.0)
            } else {
                0.0
            }
        }
    };

    let rel_x = x - horizontal_offset;
    let rel_y = y - vertical_offset;

    if let Some((cluster, side)) = Cluster::from_point(layout, rel_x, rel_y) {
        let is_leading = side == ClusterSide::Left;
        if cluster.is_rtl() {
            if is_leading {
                cluster.text_range().end
            } else {
                cluster.text_range().start
            }
        } else {
            if is_leading || cluster.is_line_break() == Some(BreakReason::Explicit) {
                cluster.text_range().start
            } else {
                cluster.text_range().end
            }
        }
    } else {
        let cursor = Cursor::from_point(layout, rel_x, rel_y);
        cursor.index()
    }
}

/// Returns the bounding rectangles (in local text coordinates `[x, y, w, h]`) of a byte range in the text.
pub fn get_range_geometry(
    text: &str,
    text_style: &TextStyle,
    avail_w: f32,
    avail_h: f32,
    range: std::ops::Range<usize>,
    shared_ctx: &SharedTextContext,
    spans: &[TextSpan<()>],
) -> Vec<[f32; 4]> {
    let mut ctx_guard = shared_ctx.lock().unwrap();
    let entry = ctx_guard.get_or_create_layout(text, text_style, avail_w, None, None, spans);
    let layout = &entry.layout;
    let actual_text_width = entry.actual_text_width;
    let actual_text_height = entry.actual_text_height;

    let horizontal_offset = match text_style.alignment {
        parley::layout::Alignment::Center => {
            if avail_w.is_finite() && avail_w > 0.0 {
                ((avail_w - actual_text_width) / 2.0).max(0.0)
            } else {
                0.0
            }
        }
        parley::layout::Alignment::End | parley::layout::Alignment::Right => {
            if avail_w.is_finite() && avail_w > 0.0 {
                (avail_w - actual_text_width).max(0.0)
            } else {
                0.0
            }
        }
        _ => 0.0,
    };

    let vertical_offset = match text_style.vertical_alignment {
        crate::style::VerticalAlignment::Top => 0.0,
        crate::style::VerticalAlignment::Center => {
            if avail_h.is_finite() && avail_h > 0.0 {
                ((avail_h - actual_text_height) / 2.0).max(0.0)
            } else {
                0.0
            }
        }
        crate::style::VerticalAlignment::Bottom => {
            if avail_h.is_finite() && avail_h > 0.0 {
                (avail_h - actual_text_height).max(0.0)
            } else {
                0.0
            }
        }
    };

    let start = range.start.min(text.len());
    let end = range.end.min(text.len());
    if start >= end {
        return Vec::new();
    }

    use parley::Selection;
    let start_cursor = Cursor::from_byte_index(layout, start, parley::layout::Affinity::Downstream);
    let end_cursor = Cursor::from_byte_index(layout, end, parley::layout::Affinity::Upstream);
    let selection_obj = Selection::new(start_cursor, end_cursor);

    let mut rects = Vec::new();
    for (bbox, _line_idx) in selection_obj.geometry(layout) {
        rects.push([
            horizontal_offset + bbox.x0 as f32,
            vertical_offset + bbox.y0 as f32,
            (bbox.x1 - bbox.x0) as f32,
            (bbox.y1 - bbox.y0) as f32,
        ]);
    }
    rects
}

pub fn get_cursor_geometry(
    text: &str,
    text_style: &TextStyle,
    avail_w: f32,
    cursor_index: usize,
    shared_ctx: &SharedTextContext,
) -> (f32, f32, f32) {
    let mut text_context = shared_ctx.lock().unwrap();
    let TextContext {
        font_cx, layout_cx, ..
    } = &mut *text_context;

    let mut builder = layout_cx.ranged_builder(font_cx, text, 1.0, true);

    builder.push_default(StyleProperty::FontSize(text_style.font_size));
    builder.push_default(parley::style::FontFamily::from(
        text_style.font_family.as_ref(),
    ));
    builder.push_default(StyleProperty::FontWeight(text_style.font_weight));
    builder.push_default(StyleProperty::FontStyle(text_style.font_style));

    if text_style.wrap {
        builder.push_default(StyleProperty::OverflowWrap(text_style.overflow_wrap));
    }

    if text_style.strikethrough {
        builder.push_default(StyleProperty::Strikethrough(true));
    }

    if text_style.underline {
        builder.push_default(StyleProperty::Underline(true));
    }

    let mut layout = builder.build(text);
    let max_advance = if text_style.wrap && avail_w.is_finite() && avail_w > 0.0 {
        Some(avail_w)
    } else {
        None
    };

    layout.break_all_lines(max_advance);
    layout.align(text_style.alignment, AlignmentOptions::default());

    let actual_text_width = layout.width();
    let horizontal_offset = match text_style.alignment {
        parley::layout::Alignment::Center => {
            if avail_w.is_finite() && avail_w > 0.0 {
                ((avail_w - actual_text_width) / 2.0).max(0.0)
            } else {
                0.0
            }
        }
        parley::layout::Alignment::End | parley::layout::Alignment::Right => {
            if avail_w.is_finite() && avail_w > 0.0 {
                (avail_w - actual_text_width).max(0.0)
            } else {
                0.0
            }
        }
        _ => 0.0,
    };

    let cursor_layout =
        Cursor::from_byte_index(&layout, cursor_index, parley::layout::Affinity::Downstream);
    let geom = cursor_layout.geometry(&layout, 1.0);
    let h = (geom.y1 - geom.y0) as f32;
    (geom.x0 as f32 + horizontal_offset, geom.y0 as f32, h)
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TextComputedOutput {
    pub computed_width: f32,
    pub computed_height: f32,
    pub baseline_offset: f32,
}

impl Default for TextComputedOutput {
    fn default() -> Self {
        Self {
            computed_width: 0.0,
            computed_height: 0.0,
            baseline_offset: 0.0,
        }
    }
}
impl From<crate::layout::TextMetrics> for TextComputedOutput {
    fn from(m: crate::layout::TextMetrics) -> Self {
        Self {
            computed_width: m.width,
            computed_height: m.height,
            baseline_offset: m.baseline_offset,
        }
    }
}

impl From<TextComputedOutput> for crate::layout::TextMetrics {
    fn from(o: TextComputedOutput) -> Self {
        Self {
            width: o.computed_width,
            height: o.computed_height,
            baseline_offset: o.baseline_offset,
        }
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct TextRenderInfo {
    pub style: TextStyle,
    pub cursor: Option<usize>,
    pub selection: Option<(usize, usize)>,
    pub preedit_range: Option<(usize, usize)>,
    pub spans: Vec<TextSpan<()>>,
}

impl Default for TextRenderInfo {
    fn default() -> Self {
        Self {
            style: TextStyle::default(),
            cursor: None,
            selection: None,
            preedit_range: None,
            spans: Vec::new(),
        }
    }
}

impl TextRenderInfo {
    pub fn new(style: TextStyle) -> Self {
        Self {
            style,
            cursor: None,
            selection: None,
            preedit_range: None,
            spans: Vec::new(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::clr;
    use parley::layout::PositionedLayoutItem;

    #[test]
    fn test_layout_span_underline_and_brush() {
        let mut text_cx = TextContext::new();
        let text_style = TextStyle::default();
        let spans = vec![
            TextSpan::new(0..2).color(clr!(blue)).underline(),
            TextSpan::new(3..12).color(clr!(red)),
        ];

        let entry = text_cx.get_or_create_layout(
            "fn calculate",
            &text_style,
            f32::INFINITY,
            None,
            None,
            &spans,
        );

        let line = entry
            .layout
            .lines()
            .next()
            .expect("Expected at least one line");
        let items: Vec<_> = line.items().collect();
        assert!(!items.is_empty());

        let mut found_underlined_blue = false;
        let mut found_non_underlined_red = false;

        for item in items {
            if let PositionedLayoutItem::GlyphRun(glyph_run) = item {
                if glyph_run.style().underline.is_some() {
                    assert_eq!(glyph_run.style().brush, clr!(blue));
                    found_underlined_blue = true;
                } else if glyph_run.style().brush == clr!(red) {
                    assert!(glyph_run.style().underline.is_none());
                    found_non_underlined_red = true;
                }
            }
        }

        assert!(
            found_underlined_blue,
            "Must find an underlined run with blue brush"
        );
        assert!(
            found_non_underlined_red,
            "Must find a non-underlined run with red brush"
        );
    }

    #[test]
    fn test_text_layout_cache_generational_promotion() {
        let mut text_cx = TextContext::new();
        text_cx.generation_capacity = 3; // Small generation capacity for deterministic testing
        let style = TextStyle::default();

        // 1. Insert 3 items to fill generation 0
        let entry1 = text_cx.get_or_create_layout("Item 1", &style, 100.0, None, None, &[]);
        let _entry2 = text_cx.get_or_create_layout("Item 2", &style, 100.0, None, None, &[]);
        let _entry3 = text_cx.get_or_create_layout("Item 3", &style, 100.0, None, None, &[]);

        assert_eq!(text_cx.current_cache.len(), 3);
        assert_eq!(text_cx.previous_cache.len(), 0);

        // 2. Insert 4th item -> causes generation rollover!
        // current_cache moves to previous_cache; 4th item goes into new current_cache
        let _entry4 = text_cx.get_or_create_layout("Item 4", &style, 100.0, None, None, &[]);
        assert_eq!(text_cx.current_cache.len(), 1);
        assert_eq!(text_cx.previous_cache.len(), 3);

        // 3. Query "Item 1" which lives in previous_cache -> should be promoted to current_cache!
        let entry1_hit = text_cx.get_or_create_layout("Item 1", &style, 100.0, None, None, &[]);
        assert!(Arc::ptr_eq(&entry1, &entry1_hit));
        assert_eq!(text_cx.current_cache.len(), 2);
        assert_eq!(text_cx.previous_cache.len(), 2); // "Item 1" was moved out of previous_cache

        // 4. Fill up current_cache until rollover again
        let _entry5 = text_cx.get_or_create_layout("Item 5", &style, 100.0, None, None, &[]);
        let _entry6 = text_cx.get_or_create_layout("Item 6", &style, 100.0, None, None, &[]);
        // Now current has 1, 4, 5, 6 -> rollover!
        // "Item 2" and "Item 3" (which were never queried) get naturally evicted!
        assert!(
            !text_cx
                .current_cache
                .keys()
                .any(|k| k.text == "Item 2" || k.text == "Item 3")
        );
        assert!(
            !text_cx
                .previous_cache
                .keys()
                .any(|k| k.text == "Item 2" || k.text == "Item 3")
        );
        // But "Item 1" survived into previous_cache because it was promoted!
        assert!(text_cx.previous_cache.keys().any(|k| k.text == "Item 1"));
    }
}