table.rs

//! ASCII Table Renderer
//!
//! Provides complete ASCII box-drawing table rendering with:
//! - Full box-drawing border characters
//! - Column alignment (left, center, right)
//! - Unicode-aware width calculation
//! - Automatic column width distribution
//! - Content truncation with ellipsis
//!
//! ## Example Output
//!
//! ```text
//! ┌──────────┬───────────┬─────────┐
//! │ Header 1 │ Header 2  │ Header 3│
//! ├──────────┼───────────┼─────────┤
//! │ Cell 1   │ Cell 2    │ Cell 3  │
//! │ Cell 4   │ Cell 5    │ Cell 6  │
//! └──────────┴───────────┴─────────┘
//! ```
//!
//! ## Usage
//!
//! ```rust,ignore
//! use cortex_engine::markdown::table::{TableBuilder, render_table, Alignment};
//! use ratatui::style::{Style, Color};
//!
//! let mut builder = TableBuilder::new();
//! builder.start_header();
//! builder.add_cell("Name".to_string());
//! builder.add_cell("Value".to_string());
//! builder.end_header();
//!
//! builder.start_row();
//! builder.add_cell("foo".to_string());
//! builder.add_cell("bar".to_string());
//! builder.end_row();
//!
//! builder.set_alignments(vec![Alignment::Left, Alignment::Right]);
//! let table = builder.build();
//!
//! let lines = render_table(
//!     &table,
//!     Color::Gray,
//!     Style::default().fg(Color::White),
//!     Style::default(),
//!     80,
//! );
//! ```

use ratatui::style::{Color, Style};
use ratatui::text::{Line, Span};
use unicode_width::UnicodeWidthStr;

// ============================================================
// BORDER CHARACTERS MODULE
// ============================================================

/// ASCII box-drawing border characters for table rendering.
pub mod border {
    /// Top-left corner: ┌
    pub const TOP_LEFT: char = '\u{250C}';
    /// Top-right corner: ┐
    pub const TOP_RIGHT: char = '\u{2510}';
    /// Bottom-left corner: └
    pub const BOTTOM_LEFT: char = '\u{2514}';
    /// Bottom-right corner: ┘
    pub const BOTTOM_RIGHT: char = '\u{2518}';
    /// Horizontal line: ─
    pub const HORIZONTAL: char = '\u{2500}';
    /// Vertical line: │
    pub const VERTICAL: char = '\u{2502}';
    /// Cross intersection: ┼
    pub const CROSS: char = '\u{253C}';
    /// T-down (top tee): ┬
    pub const T_DOWN: char = '\u{252C}';
    /// T-up (bottom tee): ┴
    pub const T_UP: char = '\u{2534}';
    /// T-right (left tee): ├
    pub const T_RIGHT: char = '\u{251C}';
    /// T-left (right tee): ┤
    pub const T_LEFT: char = '\u{2524}';
}

// ============================================================
// ALIGNMENT ENUM
// ============================================================

/// Alignment for table columns.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Alignment {
    /// Left-align content (default)
    #[default]
    Left,
    /// Center content
    Center,
    /// Right-align content
    Right,
}

// ============================================================
// TABLE CELL
// ============================================================

/// A single table cell containing text content and optional styled spans.
#[derive(Debug, Clone)]
pub struct TableCell {
    /// Raw text content of the cell
    pub content: String,
    /// Styled spans for rendering (if different from plain content)
    pub spans: Vec<Span<'static>>,
}

impl TableCell {
    /// Creates a new table cell with the given content.
    ///
    /// The spans will be set to a single unstyled span containing the content.
    pub fn new(content: impl Into<String>) -> Self {
        let content = content.into();
        let spans = vec![Span::raw(content.clone())];
        Self { content, spans }
    }

    /// Creates a new table cell with pre-styled spans.
    ///
    /// # Arguments
    /// * `content` - The raw text content (used for width calculation)
    /// * `spans` - Pre-styled spans for rendering
    pub fn with_spans(content: String, spans: Vec<Span<'static>>) -> Self {
        Self { content, spans }
    }

    /// Returns the display width of the cell content.
    ///
    /// Uses unicode-width for proper handling of:
    /// - Multi-byte UTF-8 characters
    /// - Wide characters (CJK, emoji)
    /// - Zero-width characters
    #[inline]
    pub fn width(&self) -> usize {
        UnicodeWidthStr::width(self.content.as_str())
    }
}

impl Default for TableCell {
    fn default() -> Self {
        Self::new("")
    }
}

// ============================================================
// TABLE
// ============================================================

/// Minimum column width (excluding borders)
const MIN_COLUMN_WIDTH: usize = 3;

/// Padding on each side of cell content
const CELL_PADDING: usize = 1;

/// A complete table with headers, rows, alignments, and calculated widths.
#[derive(Debug, Clone)]
pub struct Table {
    /// Header cells
    pub headers: Vec<TableCell>,
    /// Data rows (each row is a vector of cells)
    pub rows: Vec<Vec<TableCell>>,
    /// Column alignments
    pub alignments: Vec<Alignment>,
    /// Calculated column widths (content width, excluding borders/padding)
    pub column_widths: Vec<usize>,
}

impl Table {
    /// Creates a new table with the given headers, rows, and alignments.
    ///
    /// Column widths are initialized to zero and should be calculated
    /// using `calculate_column_widths` before rendering.
    pub fn new(
        headers: Vec<TableCell>,
        rows: Vec<Vec<TableCell>>,
        alignments: Vec<Alignment>,
    ) -> Self {
        let num_cols = headers
            .len()
            .max(rows.iter().map(|r| r.len()).max().unwrap_or(0));

        // Extend alignments to match column count
        let mut alignments = alignments;
        alignments.resize(num_cols, Alignment::default());

        Self {
            headers,
            rows,
            alignments,
            column_widths: vec![0; num_cols],
        }
    }

    /// Returns true if the table has no content.
    #[inline]
    pub fn is_empty(&self) -> bool {
        self.headers.is_empty() && self.rows.is_empty()
    }

    /// Returns the number of columns in the table.
    #[inline]
    pub fn num_columns(&self) -> usize {
        self.column_widths.len()
    }

    /// Calculates optimal column widths based on content and max_width.
    ///
    /// The algorithm:
    /// 1. Calculate minimum width per column (longest word or MIN_COLUMN_WIDTH)
    /// 2. Calculate preferred width (full content width)
    /// 3. Distribute available space proportionally
    /// 4. Respect max_width parameter
    ///
    /// # Arguments
    /// * `max_width` - Maximum total table width including borders
    pub fn calculate_column_widths(&mut self, max_width: u16) {
        let num_cols = self.num_columns();
        if num_cols == 0 {
            return;
        }

        // Calculate minimum and preferred widths for each column
        let mut min_widths = vec![MIN_COLUMN_WIDTH; num_cols];
        let mut pref_widths = vec![MIN_COLUMN_WIDTH; num_cols];

        // Process headers
        for (i, cell) in self.headers.iter().enumerate() {
            if i < num_cols {
                let cell_width = cell.width();
                let min_word = longest_word_width(&cell.content);
                min_widths[i] = min_widths[i].max(min_word).max(MIN_COLUMN_WIDTH);
                pref_widths[i] = pref_widths[i].max(cell_width);
            }
        }

        // Process data rows
        for row in &self.rows {
            for (i, cell) in row.iter().enumerate() {
                if i < num_cols {
                    let cell_width = cell.width();
                    let min_word = longest_word_width(&cell.content);
                    min_widths[i] = min_widths[i].max(min_word).max(MIN_COLUMN_WIDTH);
                    pref_widths[i] = pref_widths[i].max(cell_width);
                }
            }
        }

        // Calculate available width for content
        // Border chars: │ at start, │ between each column, │ at end = num_cols + 1
        // Padding: CELL_PADDING on each side of content = 2 * CELL_PADDING * num_cols
        let border_overhead = num_cols + 1;
        let padding_overhead = 2 * CELL_PADDING * num_cols;
        let total_overhead = border_overhead + padding_overhead;

        let available_width = if (max_width as usize) > total_overhead {
            (max_width as usize) - total_overhead
        } else {
            // Not enough space, use minimum possible
            num_cols * MIN_COLUMN_WIDTH
        };

        // Calculate total minimum and preferred widths
        let total_min: usize = min_widths.iter().sum();
        let total_pref: usize = pref_widths.iter().sum();

        if total_pref <= available_width {
            // All preferred widths fit
            self.column_widths = pref_widths;
        } else if total_min <= available_width {
            // Distribute extra space proportionally
            let extra_space = available_width - total_min;
            let pref_extra: usize = pref_widths
                .iter()
                .zip(min_widths.iter())
                .map(|(p, m)| p.saturating_sub(*m))
                .sum();

            self.column_widths = min_widths.clone();

            if pref_extra > 0 {
                for i in 0..num_cols {
                    let col_extra = pref_widths[i].saturating_sub(min_widths[i]);
                    let allocated =
                        (col_extra as f64 / pref_extra as f64 * extra_space as f64) as usize;
                    self.column_widths[i] += allocated;
                }
            }
        } else {
            // Not enough space even for minimums, use minimums anyway
            self.column_widths = min_widths;
        }
    }
}

impl Default for Table {
    fn default() -> Self {
        Self {
            headers: Vec::new(),
            rows: Vec::new(),
            alignments: Vec::new(),
            column_widths: Vec::new(),
        }
    }
}

// ============================================================
// TABLE BUILDER
// ============================================================

/// Builder for constructing tables incrementally.
///
/// Useful when parsing markdown tables where content arrives piece by piece.
#[derive(Debug, Default)]
pub struct TableBuilder {
    headers: Vec<TableCell>,
    rows: Vec<Vec<TableCell>>,
    alignments: Vec<Alignment>,
    current_row: Vec<TableCell>,
    in_header: bool,
}

impl TableBuilder {
    /// Creates a new empty table builder.
    pub fn new() -> Self {
        Self::default()
    }

    /// Starts building the header row.
    ///
    /// Cells added after this call will be added to the header.
    pub fn start_header(&mut self) {
        self.in_header = true;
        self.current_row.clear();
    }

    /// Ends the header row.
    ///
    /// The accumulated cells become the table headers.
    pub fn end_header(&mut self) {
        if self.in_header {
            self.headers = std::mem::take(&mut self.current_row);
            self.in_header = false;
        }
    }

    /// Starts a new data row.
    ///
    /// Cells added after this call will be added to the current row.
    pub fn start_row(&mut self) {
        self.current_row.clear();
    }

    /// Ends the current data row.
    ///
    /// The accumulated cells are added as a new row.
    pub fn end_row(&mut self) {
        if !self.in_header && !self.current_row.is_empty() {
            self.rows.push(std::mem::take(&mut self.current_row));
        }
    }

    /// Adds a cell to the current row (header or data).
    ///
    /// # Arguments
    /// * `content` - The text content of the cell
    pub fn add_cell(&mut self, content: String) {
        self.current_row.push(TableCell::new(content));
    }

    /// Adds a cell with styled spans.
    ///
    /// # Arguments
    /// * `content` - The raw text content (for width calculation)
    /// * `spans` - Pre-styled spans for rendering
    pub fn add_cell_with_spans(&mut self, content: String, spans: Vec<Span<'static>>) {
        self.current_row.push(TableCell::with_spans(content, spans));
    }

    /// Sets the column alignments.
    ///
    /// # Arguments
    /// * `alignments` - Vector of alignments, one per column
    pub fn set_alignments(&mut self, alignments: Vec<Alignment>) {
        self.alignments = alignments;
    }

    /// Builds the final table.
    ///
    /// Note: Call `calculate_column_widths` on the result before rendering.
    pub fn build(self) -> Table {
        Table::new(self.headers, self.rows, self.alignments)
    }
}

// ============================================================
// RENDER FUNCTIONS
// ============================================================

/// Renders a table to Lines with full ASCII borders.
///
/// # Arguments
/// * `table` - The table to render
/// * `border_color` - Color for border characters
/// * `header_style` - Style for header cell content
/// * `cell_style` - Style for data cell content
/// * `max_width` - Maximum total width for the table
///
/// # Returns
/// A vector of `Line`s ready for display in ratatui.
pub fn render_table(
    table: &Table,
    border_color: Color,
    header_style: Style,
    cell_style: Style,
    max_width: u16,
) -> Vec<Line<'static>> {
    // Handle empty table
    if table.is_empty() {
        return Vec::new();
    }

    // Clone and calculate widths if not already done
    let mut table = table.clone();
    if table.column_widths.iter().all(|&w| w == 0) {
        table.calculate_column_widths(max_width);
    }

    // Handle case where we still have no columns
    if table.num_columns() == 0 {
        return Vec::new();
    }

    let border_style = Style::default().fg(border_color);
    let widths = &table.column_widths;
    let alignments = &table.alignments;

    let mut lines = Vec::new();

    // Top border: ┌──────┬──────┐
    lines.push(render_horizontal_line(
        widths,
        border::TOP_LEFT,
        border::T_DOWN,
        border::TOP_RIGHT,
        border_style,
    ));

    // Header row
    if !table.headers.is_empty() {
        lines.push(render_row(
            &table.headers,
            widths,
            alignments,
            header_style,
            border_style,
        ));

        // Header separator: ├──────┼──────┤
        lines.push(render_horizontal_line(
            widths,
            border::T_RIGHT,
            border::CROSS,
            border::T_LEFT,
            border_style,
        ));
    }

    // Data rows
    for row in &table.rows {
        lines.push(render_row(
            row,
            widths,
            alignments,
            cell_style,
            border_style,
        ));
    }

    // Bottom border: └──────┴──────┘
    lines.push(render_horizontal_line(
        widths,
        border::BOTTOM_LEFT,
        border::T_UP,
        border::BOTTOM_RIGHT,
        border_style,
    ));

    lines
}

/// Renders a table as a simple ASCII code block without outer borders.
///
/// This produces a cleaner, minimal table format suitable for code blocks:
/// ```text
/// Header 1 | Header 2  | Header 3
/// ---------+-----------+---------
/// Cell 1   | Cell 2    | Cell 3
/// Cell 4   | Cell 5    | Cell 6
/// ```
///
/// # Arguments
/// * `table` - The table to render
/// * `header_style` - Style for header text (colored/bold headers)
/// * `cell_style` - Style for data cell text
/// * `max_width` - Maximum total width for the table
///
/// # Returns
/// A vector of `Line`s ready for display in ratatui.
pub fn render_table_simple(
    table: &Table,
    header_style: Style,
    cell_style: Style,
    max_width: u16,
) -> Vec<Line<'static>> {
    // Handle empty table
    if table.is_empty() {
        return Vec::new();
    }

    // Clone and calculate widths if not already done
    let mut table = table.clone();
    if table.column_widths.iter().all(|&w| w == 0) {
        table.calculate_column_widths(max_width);
    }

    // Handle case where we still have no columns
    if table.num_columns() == 0 {
        return Vec::new();
    }

    let widths = &table.column_widths;
    let alignments = &table.alignments;

    let mut lines = Vec::new();

    // Header row (if present) - use header_style for colored headers
    if !table.headers.is_empty() {
        lines.push(render_simple_row(
            &table.headers,
            widths,
            alignments,
            header_style,
        ));

        // Header separator line: ---+---+---
        lines.push(render_simple_separator(widths, cell_style));
    }

    // Data rows - use cell_style
    for row in &table.rows {
        lines.push(render_simple_row(row, widths, alignments, cell_style));
    }

    lines
}

/// Renders a simple row without outer borders.
///
/// Format: `content | content | content`
fn render_simple_row(
    cells: &[TableCell],
    widths: &[usize],
    alignments: &[Alignment],
    style: Style,
) -> Line<'static> {
    let mut spans = Vec::new();

    for (i, width) in widths.iter().enumerate() {
        // Get cell content or empty string if missing
        let cell = cells.get(i);
        let content = cell.map(|c| c.content.as_str()).unwrap_or("");
        let alignment = alignments.get(i).copied().unwrap_or_default();

        // Truncate and align
        let truncated = truncate_with_ellipsis(content, *width);
        let aligned = align_text(&truncated, *width, alignment);

        // Add cell content with padding
        spans.push(Span::styled(format!(" {} ", aligned), style));

        // Add separator between columns (not after last)
        if i < widths.len() - 1 {
            spans.push(Span::styled("|", style));
        }
    }

    Line::from(spans)
}

/// Renders a simple separator line for the header.
///
/// Format: `---+---+---`
fn render_simple_separator(widths: &[usize], style: Style) -> Line<'static> {
    let mut spans = Vec::new();

    for (i, &width) in widths.iter().enumerate() {
        // Each column segment: padding + content + padding (same as cell)
        let segment_width = width + 2; // +2 for the spaces on each side
        let segment: String = std::iter::repeat('-').take(segment_width).collect();
        spans.push(Span::styled(segment, style));

        // Add separator between columns (not after last)
        if i < widths.len() - 1 {
            spans.push(Span::styled("+", style));
        }
    }

    Line::from(spans)
}

/// Renders a horizontal border line.
///
/// # Arguments
/// * `widths` - Column widths (content only, excluding padding)
/// * `left` - Left corner/tee character
/// * `mid` - Middle intersection character
/// * `right` - Right corner/tee character
/// * `border_style` - Style for border characters
fn render_horizontal_line(
    widths: &[usize],
    left: char,
    mid: char,
    right: char,
    border_style: Style,
) -> Line<'static> {
    let mut spans = Vec::new();

    spans.push(Span::styled(left.to_string(), border_style));

    for (i, &width) in widths.iter().enumerate() {
        // Each column segment: padding + content + padding
        let segment_width = width + 2 * CELL_PADDING;
        let segment: String = std::iter::repeat(border::HORIZONTAL)
            .take(segment_width)
            .collect();
        spans.push(Span::styled(segment, border_style));

        if i < widths.len() - 1 {
            spans.push(Span::styled(mid.to_string(), border_style));
        }
    }

    spans.push(Span::styled(right.to_string(), border_style));

    Line::from(spans)
}

/// Renders a single row of cells.
///
/// # Arguments
/// * `cells` - The cells in this row
/// * `widths` - Column widths
/// * `alignments` - Column alignments
/// * `style` - Style for cell content
/// * `border_style` - Style for border characters
fn render_row(
    cells: &[TableCell],
    widths: &[usize],
    alignments: &[Alignment],
    style: Style,
    border_style: Style,
) -> Line<'static> {
    let mut spans = Vec::new();

    // Left border
    spans.push(Span::styled(border::VERTICAL.to_string(), border_style));

    for (i, width) in widths.iter().enumerate() {
        // Get cell content or empty string if missing
        let cell = cells.get(i);
        let content = cell.map(|c| c.content.as_str()).unwrap_or("");
        let alignment = alignments.get(i).copied().unwrap_or_default();

        // Truncate and align
        let truncated = truncate_with_ellipsis(content, *width);
        let aligned = align_text(&truncated, *width, alignment);

        // Left padding
        spans.push(Span::styled(" ".repeat(CELL_PADDING), style));

        // Cell content - use spans if available, otherwise plain text
        if let Some(cell) = cell {
            if cell.spans.len() == 1 && cell.spans[0].content == cell.content {
                // Simple case: just style the aligned text
                spans.push(Span::styled(aligned, style));
            } else {
                // Complex case: we have styled spans, need to handle alignment
                // For now, just use the aligned plain text with the base style
                spans.push(Span::styled(aligned, style));
            }
        } else {
            spans.push(Span::styled(aligned, style));
        }

        // Right padding
        spans.push(Span::styled(" ".repeat(CELL_PADDING), style));

        // Column separator or right border
        spans.push(Span::styled(border::VERTICAL.to_string(), border_style));
    }

    Line::from(spans)
}

/// Aligns text within a given width.
///
/// # Arguments
/// * `text` - The text to align
/// * `width` - The target width
/// * `alignment` - The alignment type
fn align_text(text: &str, width: usize, alignment: Alignment) -> String {
    let text_width = UnicodeWidthStr::width(text);

    if text_width >= width {
        return text.to_string();
    }

    let padding = width - text_width;

    match alignment {
        Alignment::Left => {
            format!("{}{}", text, " ".repeat(padding))
        }
        Alignment::Right => {
            format!("{}{}", " ".repeat(padding), text)
        }
        Alignment::Center => {
            let left_pad = padding / 2;
            let right_pad = padding - left_pad;
            format!("{}{}{}", " ".repeat(left_pad), text, " ".repeat(right_pad))
        }
    }
}

/// Truncates text with ellipsis if it exceeds max_width.
///
/// # Arguments
/// * `text` - The text to potentially truncate
/// * `max_width` - Maximum allowed display width
///
/// # Returns
/// The original text if it fits, or truncated text with "..." appended.
fn truncate_with_ellipsis(text: &str, max_width: usize) -> String {
    let text_width = UnicodeWidthStr::width(text);

    if text_width <= max_width {
        return text.to_string();
    }

    if max_width <= 3 {
        // Not enough space for ellipsis, just return dots
        return ".".repeat(max_width);
    }

    // We need to fit text + "..." into max_width
    let target_width = max_width - 3; // Reserve 3 chars for "..."

    let mut result = String::new();
    let mut current_width = 0;

    for ch in text.chars() {
        let ch_width = unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0);
        if current_width + ch_width > target_width {
            break;
        }
        result.push(ch);
        current_width += ch_width;
    }

    result.push_str("...");
    result
}

/// Calculates the width of the longest word in a string.
///
/// Words are split by whitespace. This is used for minimum column width calculation.
fn longest_word_width(text: &str) -> usize {
    text.split_whitespace()
        .map(|word| UnicodeWidthStr::width(word))
        .max()
        .unwrap_or(MIN_COLUMN_WIDTH)
        .max(MIN_COLUMN_WIDTH)
}

// ============================================================
// TESTS
// ============================================================

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

    #[test]
    fn test_empty_table() {
        let table = Table::default();
        assert!(table.is_empty());

        let lines = render_table(&table, Color::Gray, Style::default(), Style::default(), 80);
        assert!(lines.is_empty());
    }

    #[test]
    fn test_single_cell() {
        let mut builder = TableBuilder::new();
        builder.start_header();
        builder.add_cell("Header".to_string());
        builder.end_header();

        builder.start_row();
        builder.add_cell("Value".to_string());
        builder.end_row();

        let table = builder.build();
        assert!(!table.is_empty());
        assert_eq!(table.num_columns(), 1);

        let lines = render_table(&table, Color::Gray, Style::default(), Style::default(), 80);

        // Should have: top border, header, separator, data row, bottom border = 5 lines
        assert_eq!(lines.len(), 5);
    }

    #[test]
    fn test_multiple_columns_and_alignments() {
        let mut builder = TableBuilder::new();
        builder.start_header();
        builder.add_cell("Left".to_string());
        builder.add_cell("Center".to_string());
        builder.add_cell("Right".to_string());
        builder.end_header();

        builder.start_row();
        builder.add_cell("A".to_string());
        builder.add_cell("B".to_string());
        builder.add_cell("C".to_string());
        builder.end_row();

        builder.set_alignments(vec![Alignment::Left, Alignment::Center, Alignment::Right]);

        let table = builder.build();
        assert_eq!(table.num_columns(), 3);
        assert_eq!(table.alignments[0], Alignment::Left);
        assert_eq!(table.alignments[1], Alignment::Center);
        assert_eq!(table.alignments[2], Alignment::Right);
    }

    #[test]
    fn test_unicode_content() {
        let mut builder = TableBuilder::new();
        builder.start_header();
        builder.add_cell("Language".to_string());
        builder.add_cell("Greeting".to_string());
        builder.end_header();

        builder.start_row();
        builder.add_cell("Japanese".to_string());
        builder.add_cell("こんにちは".to_string());
        builder.end_row();

        builder.start_row();
        builder.add_cell("Chinese".to_string());
        builder.add_cell("你好".to_string());
        builder.end_row();

        builder.start_row();
        builder.add_cell("Emoji".to_string());
        builder.add_cell("Hello! \u{1F44B}".to_string());
        builder.end_row();

        let table = builder.build();
        let lines = render_table(&table, Color::Gray, Style::default(), Style::default(), 80);

        // Should have: top border, header, separator, 3 data rows, bottom border = 7 lines
        assert_eq!(lines.len(), 7);
    }

    #[test]
    fn test_truncation() {
        let result = truncate_with_ellipsis("Hello, World!", 8);
        assert_eq!(result, "Hello...");

        let result = truncate_with_ellipsis("Hi", 10);
        assert_eq!(result, "Hi");

        let result = truncate_with_ellipsis("Hello", 3);
        assert_eq!(result, "...");

        let result = truncate_with_ellipsis("Hello", 2);
        assert_eq!(result, "..");
    }

    #[test]
    fn test_alignment() {
        assert_eq!(align_text("Hi", 6, Alignment::Left), "Hi    ");
        assert_eq!(align_text("Hi", 6, Alignment::Right), "    Hi");
        assert_eq!(align_text("Hi", 6, Alignment::Center), "  Hi  ");
        assert_eq!(align_text("Hi", 7, Alignment::Center), "  Hi   ");
    }

    #[test]
    fn test_cell_width() {
        let cell = TableCell::new("Hello");
        assert_eq!(cell.width(), 5);

        let cell = TableCell::new("こんにちは"); // 5 wide chars = 10 width
        assert_eq!(cell.width(), 10);

        let cell = TableCell::new("");
        assert_eq!(cell.width(), 0);
    }

    #[test]
    fn test_column_width_calculation() {
        let mut builder = TableBuilder::new();
        builder.start_header();
        builder.add_cell("Short".to_string());
        builder.add_cell("A much longer header".to_string());
        builder.end_header();

        builder.start_row();
        builder.add_cell("A".to_string());
        builder.add_cell("B".to_string());
        builder.end_row();

        let mut table = builder.build();
        table.calculate_column_widths(80);

        // First column should be at least 5 (length of "Short")
        assert!(table.column_widths[0] >= 5);
        // Second column should be at least 20 (length of "A much longer header")
        assert!(table.column_widths[1] >= 20);
    }

    #[test]
    fn test_missing_cells_in_rows() {
        let mut builder = TableBuilder::new();
        builder.start_header();
        builder.add_cell("A".to_string());
        builder.add_cell("B".to_string());
        builder.add_cell("C".to_string());
        builder.end_header();

        builder.start_row();
        builder.add_cell("1".to_string());
        // Missing cells B and C
        builder.end_row();

        builder.start_row();
        builder.add_cell("2".to_string());
        builder.add_cell("3".to_string());
        // Missing cell C
        builder.end_row();

        let table = builder.build();
        let lines = render_table(&table, Color::Gray, Style::default(), Style::default(), 80);

        // Should render without panicking
        assert!(!lines.is_empty());
    }

    #[test]
    fn test_narrow_max_width() {
        let mut builder = TableBuilder::new();
        builder.start_header();
        builder.add_cell("Very Long Header Name".to_string());
        builder.end_header();

        builder.start_row();
        builder.add_cell("Some long cell content".to_string());
        builder.end_row();

        let table = builder.build();
        let lines = render_table(
            &table,
            Color::Gray,
            Style::default(),
            Style::default(),
            20, // Very narrow
        );

        // Should still render, content will be truncated
        assert!(!lines.is_empty());
    }

    #[test]
    fn test_builder_workflow() {
        let mut builder = TableBuilder::new();

        // Header phase
        builder.start_header();
        builder.add_cell("Col1".to_string());
        builder.add_cell("Col2".to_string());
        builder.end_header();

        // Multiple rows
        for i in 0..3 {
            builder.start_row();
            builder.add_cell(format!("R{}C1", i));
            builder.add_cell(format!("R{}C2", i));
            builder.end_row();
        }

        builder.set_alignments(vec![Alignment::Left, Alignment::Right]);

        let table = builder.build();
        assert_eq!(table.headers.len(), 2);
        assert_eq!(table.rows.len(), 3);
        assert_eq!(table.alignments.len(), 2);
    }

    #[test]
    fn test_longest_word_width() {
        assert_eq!(longest_word_width("hello world"), 5);
        assert_eq!(longest_word_width("supercalifragilistic"), 20);
        assert_eq!(longest_word_width("a b c"), 3); // minimum is 3
        assert_eq!(longest_word_width(""), 3); // minimum is 3
    }

    #[test]
    fn test_border_characters() {
        assert_eq!(border::TOP_LEFT, '┌');
        assert_eq!(border::TOP_RIGHT, '┐');
        assert_eq!(border::BOTTOM_LEFT, '└');
        assert_eq!(border::BOTTOM_RIGHT, '┘');
        assert_eq!(border::HORIZONTAL, '─');
        assert_eq!(border::VERTICAL, '│');
        assert_eq!(border::CROSS, '┼');
        assert_eq!(border::T_DOWN, '┬');
        assert_eq!(border::T_UP, '┴');
        assert_eq!(border::T_RIGHT, '├');
        assert_eq!(border::T_LEFT, '┤');
    }

    #[test]
    fn test_table_without_headers() {
        let mut builder = TableBuilder::new();

        // Skip header, just add rows
        builder.start_row();
        builder.add_cell("A".to_string());
        builder.add_cell("B".to_string());
        builder.end_row();

        builder.start_row();
        builder.add_cell("C".to_string());
        builder.add_cell("D".to_string());
        builder.end_row();

        let table = builder.build();
        assert!(table.headers.is_empty());
        assert_eq!(table.rows.len(), 2);

        let lines = render_table(&table, Color::Gray, Style::default(), Style::default(), 80);

        // Should have: top border, 2 data rows, bottom border = 4 lines (no header separator)
        assert_eq!(lines.len(), 4);
    }

    #[test]
    fn test_cell_with_spans() {
        let spans = vec![
            Span::raw("Hello "),
            Span::styled("World", Style::default().fg(Color::Red)),
        ];
        let cell = TableCell::with_spans("Hello World".to_string(), spans.clone());

        assert_eq!(cell.content, "Hello World");
        assert_eq!(cell.spans.len(), 2);
        assert_eq!(cell.width(), 11);
    }

    #[test]
    fn test_various_widths() {
        let mut builder = TableBuilder::new();
        builder.start_header();
        builder.add_cell("A".to_string());
        builder.add_cell("BB".to_string());
        builder.add_cell("CCC".to_string());
        builder.end_header();

        builder.start_row();
        builder.add_cell("1".to_string());
        builder.add_cell("22".to_string());
        builder.add_cell("333".to_string());
        builder.end_row();

        let table = builder.build();

        // Test with different max widths
        for max_width in [20, 40, 60, 80, 100] {
            let lines = render_table(
                &table,
                Color::Gray,
                Style::default(),
                Style::default(),
                max_width,
            );
            assert!(!lines.is_empty(), "Failed at max_width={}", max_width);
        }
    }

    #[test]
    fn test_default_alignment() {
        let alignment = Alignment::default();
        assert_eq!(alignment, Alignment::Left);
    }

    #[test]
    fn test_default_table_cell() {
        let cell = TableCell::default();
        assert_eq!(cell.content, "");
        assert_eq!(cell.width(), 0);
    }

    // ============================================================
    // Simple Table Tests
    // ============================================================

    #[test]
    fn test_simple_table_empty() {
        let table = Table::default();
        let lines = render_table_simple(&table, Style::default(), Style::default(), 80);
        assert!(lines.is_empty());
    }

    #[test]
    fn test_simple_table_basic() {
        let mut builder = TableBuilder::new();
        builder.start_header();
        builder.add_cell("Header".to_string());
        builder.end_header();

        builder.start_row();
        builder.add_cell("Value".to_string());
        builder.end_row();

        let table = builder.build();
        let lines = render_table_simple(&table, Style::default(), Style::default(), 80);

        // Should have: header, separator, data row = 3 lines (no outer borders)
        assert_eq!(lines.len(), 3);
    }

    #[test]
    fn test_simple_table_multiple_columns() {
        let mut builder = TableBuilder::new();
        builder.start_header();
        builder.add_cell("A".to_string());
        builder.add_cell("B".to_string());
        builder.add_cell("C".to_string());
        builder.end_header();

        builder.start_row();
        builder.add_cell("1".to_string());
        builder.add_cell("2".to_string());
        builder.add_cell("3".to_string());
        builder.end_row();

        let table = builder.build();
        let lines = render_table_simple(&table, Style::default(), Style::default(), 80);

        // Check that separator line contains + characters
        let separator_content: String = lines[1].spans.iter().map(|s| &*s.content).collect();
        assert!(
            separator_content.contains('+'),
            "Separator should contain + for column separation"
        );
        assert!(
            separator_content.contains('-'),
            "Separator should contain - for dashes"
        );
    }

    #[test]
    fn test_simple_table_without_headers() {
        let mut builder = TableBuilder::new();

        builder.start_row();
        builder.add_cell("A".to_string());
        builder.add_cell("B".to_string());
        builder.end_row();

        builder.start_row();
        builder.add_cell("C".to_string());
        builder.add_cell("D".to_string());
        builder.end_row();

        let table = builder.build();
        let lines = render_table_simple(&table, Style::default(), Style::default(), 80);

        // Should have: 2 data rows only (no header, no separator)
        assert_eq!(lines.len(), 2);
    }

    #[test]
    fn test_simple_table_format() {
        let mut builder = TableBuilder::new();
        builder.start_header();
        builder.add_cell("Name".to_string());
        builder.add_cell("Value".to_string());
        builder.end_header();

        builder.start_row();
        builder.add_cell("foo".to_string());
        builder.add_cell("bar".to_string());
        builder.end_row();

        let table = builder.build();
        let lines = render_table_simple(&table, Style::default(), Style::default(), 80);

        // First line should be header with | separator
        let header_content: String = lines[0].spans.iter().map(|s| &*s.content).collect();
        assert!(
            header_content.contains('|'),
            "Header should have | separator between columns"
        );

        // Second line should be separator with -+-
        let separator_content: String = lines[1].spans.iter().map(|s| &*s.content).collect();
        assert!(
            separator_content.contains('+'),
            "Separator should have + at column intersections"
        );
    }

    #[test]
    fn test_simple_table_header_styling() {
        let mut builder = TableBuilder::new();
        builder.start_header();
        builder.add_cell("Header1".to_string());
        builder.add_cell("Header2".to_string());
        builder.end_header();

        builder.start_row();
        builder.add_cell("Cell1".to_string());
        builder.add_cell("Cell2".to_string());
        builder.end_row();

        let table = builder.build();

        // Use different styles for header and cells
        let header_style = Style::default().fg(Color::Cyan);
        let cell_style = Style::default().fg(Color::White);

        let lines = render_table_simple(&table, header_style, cell_style, 80);

        // Header row should have header_style
        assert!(!lines.is_empty());
        let header_line = &lines[0];
        // Check that header spans have the cyan color
        for span in &header_line.spans {
            if span.content.contains("Header") {
                assert_eq!(span.style.fg, Some(Color::Cyan));
            }
        }

        // Data row should have cell_style
        let data_line = &lines[2]; // After header and separator
        for span in &data_line.spans {
            if span.content.contains("Cell") {
                assert_eq!(span.style.fg, Some(Color::White));
            }
        }
    }
}