tui/rendering/

soft_wrap.rs

use std::borrow::Cow;

use super::{line::Line, style::Style};
use crossterm::style::Color;
use unicode_width::UnicodeWidthChar;

/// Truncates text to fit within `max_width` display columns, appending "..." if truncated.
/// Returns the original string borrowed when no truncation is needed.
pub fn truncate_text(text: &str, max_width: usize) -> Cow<'_, str> {
    const ELLIPSIS: &str = "...";
    const ELLIPSIS_WIDTH: usize = 3;

    if max_width == 0 {
        return Cow::Borrowed("");
    }

    let use_ellipsis = max_width >= ELLIPSIS_WIDTH;
    let budget = if use_ellipsis { max_width - ELLIPSIS_WIDTH } else { max_width };

    let mut width = 0;
    let mut fit_end = 0; // byte offset after last char fitting within budget

    for (i, ch) in text.char_indices() {
        let cw = UnicodeWidthChar::width(ch).unwrap_or(0);
        if width + cw > max_width {
            return if use_ellipsis {
                Cow::Owned(format!("{}{ELLIPSIS}", &text[..fit_end]))
            } else {
                Cow::Owned(text[..fit_end].to_owned())
            };
        }
        width += cw;
        if width <= budget {
            fit_end = i + ch.len_utf8();
        }
    }

    Cow::Borrowed(text)
}

/// Pads `text` with trailing spaces to reach `target_width` display columns.
/// Returns the original text unchanged if it already meets or exceeds the target.
pub fn pad_text_to_width(text: &str, target_width: usize) -> Cow<'_, str> {
    let current = display_width_text(text);
    if current >= target_width {
        Cow::Borrowed(text)
    } else {
        let padding = target_width - current;
        Cow::Owned(format!("{text}{}", " ".repeat(padding)))
    }
}

pub fn display_width_text(s: &str) -> usize {
    s.chars().map(|ch| UnicodeWidthChar::width(ch).unwrap_or(0)).sum()
}

pub fn display_width_line(line: &Line) -> usize {
    line.spans().iter().map(|span| display_width_text(span.text())).sum()
}

/// Truncates a styled line to fit within `max_width` display columns.
///
/// Walks spans tracking cumulative display width, slicing at the character
/// boundary where the budget is exhausted. No ellipsis is appended — callers
/// can pad with [`Line::extend_bg_to_width`] if needed.
///
/// Row-fill metadata on the source line is preserved on the result.
pub fn truncate_line(line: &Line, max_width: usize) -> Line {
    if max_width == 0 {
        let mut empty = Line::default();
        empty.set_fill(line.fill());
        return empty;
    }

    let mut result = Line::default();
    let mut remaining = max_width;

    for span in line.spans() {
        if remaining == 0 {
            break;
        }

        let text = span.text();
        let style = span.style();
        let mut byte_end = 0;
        let mut col = 0;

        for (i, ch) in text.char_indices() {
            let cw = UnicodeWidthChar::width(ch).unwrap_or(0);
            if col + cw > remaining {
                break;
            }
            col += cw;
            byte_end = i + ch.len_utf8();
        }

        if byte_end > 0 {
            result.push_with_style(&text[..byte_end], style);
        }
        remaining -= col;
    }

    result.set_fill(line.fill());
    result
}

pub fn soft_wrap_line(line: &Line, width: u16) -> Vec<Line> {
    if line.is_empty() {
        let mut empty = Line::new("");
        empty.set_fill(line.fill());
        return vec![empty];
    }

    let max_width = width as usize;
    if max_width == 0 {
        return vec![line.clone()];
    }

    let cells = to_cells(line);
    let mut rows = Vec::new();
    let mut row_start = 0usize;
    let mut row_width = 0usize;
    let mut last_ws = None;
    let mut i = 0usize;

    while i < cells.len() {
        let cell = cells[i];

        if cell.ch == '\n' {
            rows.push(to_line(&cells[row_start..i], line.fill()));
            row_start = i + 1;
            row_width = 0;
            last_ws = None;
            i += 1;
            continue;
        }

        if cell.width > 0 && row_width + cell.width > max_width && row_width > 0 {
            let split_start = row_start;
            let (row_end, next_row_start) = if cell.ch.is_whitespace() {
                (i, i + 1)
            } else if let Some(ws) = last_ws {
                (ws, ws + 1)
            } else {
                (i, i)
            };

            rows.push(to_line(&cells[split_start..row_end], line.fill()));
            row_start = next_row_start;

            if row_start > i {
                row_width = 0;
                last_ws = None;
                i += 1;
                continue;
            }

            row_width = display_width_cells(&cells[row_start..i]);
            last_ws = last_whitespace_index(&cells[row_start..i]).map(|offset| row_start + offset);
            continue;
        }

        row_width += cell.width;
        if cell.ch.is_whitespace() {
            last_ws = Some(i);
        }
        i += 1;
    }

    rows.push(to_line(&cells[row_start..], line.fill()));
    rows
}

pub fn soft_wrap_lines_with_map(lines: &[Line], width: u16) -> (Vec<Line>, Vec<usize>) {
    let mut out = Vec::new();
    let mut starts = Vec::with_capacity(lines.len());

    for line in lines {
        starts.push(out.len());
        out.extend(soft_wrap_line(line, width));
    }

    (out, starts)
}

#[derive(Clone, Copy)]
struct SoftWrapCell {
    ch: char,
    style: Style,
    width: usize,
}

fn to_cells(line: &Line) -> Vec<SoftWrapCell> {
    line.spans()
        .iter()
        .flat_map(|span| {
            let style = span.style();
            span.text().chars().map(move |ch| SoftWrapCell {
                ch,
                style,
                width: UnicodeWidthChar::width(ch).unwrap_or(0),
            })
        })
        .collect()
}

fn to_line(cells: &[SoftWrapCell], fill: Option<Color>) -> Line {
    let mut line = Line::default();
    for cell in cells {
        let mut ch = [0; 4];
        line.push_with_style(cell.ch.encode_utf8(&mut ch), cell.style);
    }

    line.set_fill(fill);
    line
}

fn display_width_cells(cells: &[SoftWrapCell]) -> usize {
    cells.iter().map(|cell| cell.width).sum()
}

fn last_whitespace_index(cells: &[SoftWrapCell]) -> Option<usize> {
    cells.iter().rposition(|cell| cell.ch.is_whitespace())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crossterm::style::Color;

    #[test]
    fn wraps_ascii_to_width() {
        let rows = soft_wrap_line(&Line::new("abcdef"), 3);
        assert_eq!(rows, vec![Line::new("abc"), Line::new("def")]);
    }

    #[test]
    fn display_width_ignores_style() {
        let mut line = Line::default();
        line.push_styled("he", Color::Red);
        line.push_text("llo");
        assert_eq!(display_width_line(&line), 5);
    }

    #[test]
    fn wraps_preserving_style_spans() {
        let line = Line::styled("abcdef", Color::Red);
        let rows = soft_wrap_line(&line, 3);
        assert_eq!(rows.len(), 2);
        assert_eq!(rows[0].plain_text(), "abc");
        assert_eq!(rows[1].plain_text(), "def");
        assert_eq!(rows[0].spans().len(), 1);
        assert_eq!(rows[1].spans().len(), 1);
        assert_eq!(rows[0].spans()[0].style().fg, Some(Color::Red));
        assert_eq!(rows[1].spans()[0].style().fg, Some(Color::Red));
    }

    #[test]
    fn counts_wide_unicode() {
        assert_eq!(display_width_text("中a"), 3);
        let rows = soft_wrap_line(&Line::new("中ab"), 3);
        assert_eq!(rows, vec![Line::new("中a"), Line::new("b")]);
    }

    #[test]
    fn wraps_multi_span_line_mid_span() {
        let mut line = Line::default();
        line.push_styled("ab", Color::Red);
        line.push_styled("cd", Color::Blue);
        line.push_styled("ef", Color::Green);
        let rows = soft_wrap_line(&line, 3);
        assert_eq!(rows.len(), 2);
        assert_eq!(rows[0].plain_text(), "abc");
        assert_eq!(rows[1].plain_text(), "def");
        // First row: "ab" (Red) + "c" (Blue)
        assert_eq!(rows[0].spans().len(), 2);
        assert_eq!(rows[0].spans()[0].style().fg, Some(Color::Red));
        assert_eq!(rows[0].spans()[1].style().fg, Some(Color::Blue));
        // Second row: "d" (Blue) + "ef" (Green)
        assert_eq!(rows[1].spans().len(), 2);
        assert_eq!(rows[1].spans()[0].style().fg, Some(Color::Blue));
        assert_eq!(rows[1].spans()[1].style().fg, Some(Color::Green));
    }

    #[test]
    fn wraps_line_with_embedded_newlines() {
        let line = Line::new("abc\ndef");
        let rows = soft_wrap_line(&line, 80);
        assert_eq!(rows.len(), 2);
        assert_eq!(rows[0].plain_text(), "abc");
        assert_eq!(rows[1].plain_text(), "def");
    }

    #[test]
    fn pad_text_pads_ascii_to_target_width() {
        let result = pad_text_to_width("hello", 10);
        assert_eq!(result, "hello     ");
        assert_eq!(display_width_text(&result), 10);
    }

    #[test]
    fn pad_text_returns_borrowed_when_already_wide_enough() {
        let result = pad_text_to_width("hello", 5);
        assert!(matches!(result, Cow::Borrowed(_)));
        assert_eq!(result, "hello");

        let result = pad_text_to_width("hello", 3);
        assert!(matches!(result, Cow::Borrowed(_)));
        assert_eq!(result, "hello");
    }

    #[test]
    fn pad_text_handles_wide_unicode() {
        // "中" is 2 display columns wide
        let result = pad_text_to_width("中a", 6);
        assert_eq!(display_width_text(&result), 6);
        assert_eq!(result, "中a   "); // 2+1 = 3 cols, need 3 spaces
    }

    #[test]
    fn truncate_text_fits_within_width() {
        assert_eq!(truncate_text("hello", 10), "hello");
        assert_eq!(truncate_text("hello world", 8), "hello...");
        assert_eq!(truncate_text("hello", 5), "hello");
        assert_eq!(truncate_text("hello", 4), "h...");
    }

    #[test]
    fn truncate_text_handles_wide_unicode() {
        // Chinese characters are 2 columns wide
        assert_eq!(truncate_text("中文字", 5), "中..."); // 6 cols -> truncate to 2+3=5
        assert_eq!(truncate_text("中ab", 4), "中ab"); // 2+1+1=4, fits exactly
        assert_eq!(truncate_text("中abc", 4), "..."); // 5 cols, only ellipsis fits in 4
        assert_eq!(truncate_text("中abcde", 6), "中a..."); // 7 cols -> truncate to 2+1+3=6
    }

    #[test]
    fn truncate_text_handles_zero_width() {
        assert_eq!(truncate_text("hello", 0), "");
    }

    #[test]
    fn truncate_text_max_width_1() {
        let result = truncate_text("hello", 1);
        assert!(
            display_width_text(&result) <= 1,
            "Expected width <= 1, got '{}' (width {})",
            result,
            display_width_text(&result),
        );
        assert_eq!(result, "h");
    }

    #[test]
    fn truncate_text_max_width_2() {
        let result = truncate_text("hello", 2);
        assert!(
            display_width_text(&result) <= 2,
            "Expected width <= 2, got '{}' (width {})",
            result,
            display_width_text(&result),
        );
        assert_eq!(result, "he");
    }

    #[test]
    fn truncate_line_returns_short_lines_unchanged() {
        let line = Line::new("short");
        let result = truncate_line(&line, 20);
        assert_eq!(result.plain_text(), "short");
    }

    #[test]
    fn truncate_line_trims_long_styled_lines() {
        let mut line = Line::default();
        line.push_styled("hello", Color::Red);
        line.push_styled(" world", Color::Blue);
        let result = truncate_line(&line, 7);
        assert_eq!(result.plain_text(), "hello w");
        assert_eq!(result.spans().len(), 2);
        assert_eq!(result.spans()[0].style().fg, Some(Color::Red));
        assert_eq!(result.spans()[1].style().fg, Some(Color::Blue));
    }

    #[test]
    fn truncate_line_handles_mid_span_cut() {
        let line = Line::styled("abcdefgh", Color::Green);
        let result = truncate_line(&line, 4);
        assert_eq!(result.plain_text(), "abcd");
        assert_eq!(result.spans()[0].style().fg, Some(Color::Green));
    }

    #[test]
    fn truncate_line_handles_wide_unicode_at_boundary() {
        // "中" is 2 display columns, "文" is 2.
        // Budget of 3: "中"(2) fits, "文"(2) would exceed (2+2=4>3), so stop.
        let line = Line::new("中文x");
        let result = truncate_line(&line, 3);
        assert_eq!(result.plain_text(), "中");

        // Budget of 4: "中"(2) + "文"(2) = 4, fits exactly.
        let result = truncate_line(&line, 4);
        assert_eq!(result.plain_text(), "中文");

        // Budget of 5: all fit: 2+2+1=5.
        let result = truncate_line(&line, 5);
        assert_eq!(result.plain_text(), "中文x");
    }

    #[test]
    fn truncate_line_zero_width_returns_empty() {
        let line = Line::new("hello");
        let result = truncate_line(&line, 0);
        assert!(result.is_empty());
    }

    #[test]
    fn wraps_at_word_boundary() {
        let rows = soft_wrap_line(&Line::new("hello world"), 7);
        assert_eq!(rows.len(), 2);
        assert_eq!(rows[0].plain_text(), "hello");
        assert_eq!(rows[1].plain_text(), "world");
    }

    #[test]
    fn wraps_multiple_words() {
        let rows = soft_wrap_line(&Line::new("hello world foo"), 12);
        assert_eq!(rows.len(), 2);
        assert_eq!(rows[0].plain_text(), "hello world");
        assert_eq!(rows[1].plain_text(), "foo");
    }

    #[test]
    fn falls_back_to_char_break_without_whitespace() {
        let rows = soft_wrap_line(&Line::new("superlongword next"), 5);
        assert_eq!(rows[0].plain_text(), "super");
        assert_eq!(rows[1].plain_text(), "longw");
        assert_eq!(rows[2].plain_text(), "ord");
        assert_eq!(rows[3].plain_text(), "next");
    }

    #[test]
    fn wraps_at_word_boundary_with_styled_spans() {
        let line = Line::styled("hello world", Color::Red);
        let rows = soft_wrap_line(&line, 7);
        assert_eq!(rows.len(), 2);
        assert_eq!(rows[0].plain_text(), "hello");
        assert_eq!(rows[1].plain_text(), "world");
        assert_eq!(rows[0].spans()[0].style().fg, Some(Color::Red));
        assert_eq!(rows[1].spans()[0].style().fg, Some(Color::Red));
    }

    #[test]
    fn wraps_at_whitespace_across_span_boundaries() {
        let mut line = Line::default();
        line.push_styled("@aaaaa", Color::Red);
        line.push_text(" ");
        line.push_styled("@bbbbbb", Color::Blue);

        let rows = soft_wrap_line(&line, 10);

        assert_eq!(rows.len(), 2);
        assert_eq!(rows[0].plain_text(), "@aaaaa");
        assert_eq!(rows[1].plain_text(), "@bbbbbb");
        assert_eq!(rows[0].spans()[0].style().fg, Some(Color::Red));
        assert_eq!(rows[1].spans()[0].style().fg, Some(Color::Blue));
    }

    #[test]
    fn hard_wraps_long_styled_token_without_whitespace() {
        let line = Line::styled("@abcdefghijk", Color::Green);
        let rows = soft_wrap_line(&line, 5);

        assert_eq!(rows.len(), 3);
        assert_eq!(rows[0].plain_text(), "@abcd");
        assert_eq!(rows[1].plain_text(), "efghi");
        assert_eq!(rows[2].plain_text(), "jk");
        for row in &rows {
            assert_eq!(row.spans()[0].style().fg, Some(Color::Green));
        }
    }

    #[test]
    fn drops_whitespace_when_new_span_starts_at_wrap_boundary() {
        let mut line = Line::default();
        line.push_styled("abcdefghij", Color::Red);
        line.push_styled(" klm", Color::Blue);
        let rows = soft_wrap_line(&line, 10);

        assert_eq!(rows.len(), 2);
        assert_eq!(rows[0].plain_text(), "abcdefghij");
        assert_eq!(rows[1].plain_text(), "klm");
        assert_eq!(rows[1].spans()[0].style().fg, Some(Color::Blue));
    }

    #[test]
    fn soft_wrap_propagates_fill_to_each_wrapped_row() {
        let line = Line::new("abcdef").with_fill(Color::Red);
        let rows = soft_wrap_line(&line, 3);
        assert_eq!(rows.len(), 2);
        for row in &rows {
            assert_eq!(row.fill(), Some(Color::Red));
        }
    }

    #[test]
    fn soft_wrap_preserves_fill_on_empty_line() {
        let line = Line::default().with_fill(Color::Red);
        let rows = soft_wrap_line(&line, 10);
        assert_eq!(rows.len(), 1);
        assert_eq!(rows[0].fill(), Some(Color::Red));
    }

    #[test]
    fn truncate_line_preserves_fill_metadata() {
        let line = Line::new("abcdef").with_fill(Color::Blue);
        let truncated = truncate_line(&line, 3);
        assert_eq!(truncated.plain_text(), "abc");
        assert_eq!(truncated.fill(), Some(Color::Blue));
    }

    #[test]
    fn wraps_across_spans_without_panic() {
        let mut line = Line::default();
        line.push_styled("hello ", Color::Red);
        line.push_styled("world this is long", Color::Blue);
        let rows = soft_wrap_line(&line, 10);
        assert_eq!(rows[0].plain_text(), "hello");
        assert_eq!(rows[1].plain_text(), "world this");
        assert_eq!(rows[2].plain_text(), "is long");
    }
}