SLY / src / block.rs

use crate::style::{self, Align, Line, Span};

// --- Types ---

#[derive(Debug, Clone)]
pub struct BorderChars {
    pub top: &'static str,
    pub bottom: &'static str,
    pub left: &'static str,
    pub right: &'static str,
    pub top_left: &'static str,
    pub top_right: &'static str,
    pub bottom_left: &'static str,
    pub bottom_right: &'static str,
}

#[derive(Debug, Clone)]
pub enum BorderStyle {
    NoBorder,
    Single,
    Double,
    Rounded,
    Thick,
    Ascii,
    Custom(BorderChars),
}

#[derive(Debug, Clone)]
pub enum Block {
    Text(Vec<Line>),
    Box {
        content: Box<Block>,
        border: BorderStyle,
        title: Option<Line>,
    },
    HStack {
        children: Vec<Block>,
        gap: usize,
    },
    VStack {
        children: Vec<Block>,
        gap: usize,
    },
    Empty {
        height: usize,
    },
    Sized {
        content: Box<Block>,
        min_width: Option<usize>,
        min_height: Option<usize>,
    },
    Padded {
        content: Box<Block>,
        top: usize,
        bottom: usize,
        left: usize,
        right: usize,
    },
}

// --- Border resolution ---

impl BorderStyle {
    pub fn chars(&self) -> BorderChars {
        match self {
            BorderStyle::NoBorder => BorderChars {
                top: "",
                bottom: "",
                left: "",
                right: "",
                top_left: "",
                top_right: "",
                bottom_left: "",
                bottom_right: "",
            },
            BorderStyle::Single => BorderChars {
                top: "─",
                bottom: "─",
                left: "│",
                right: "│",
                top_left: "┌",
                top_right: "┐",
                bottom_left: "└",
                bottom_right: "┘",
            },
            BorderStyle::Double => BorderChars {
                top: "═",
                bottom: "═",
                left: "║",
                right: "║",
                top_left: "╔",
                top_right: "╗",
                bottom_left: "╚",
                bottom_right: "╝",
            },
            BorderStyle::Rounded => BorderChars {
                top: "─",
                bottom: "─",
                left: "│",
                right: "│",
                top_left: "╭",
                top_right: "╮",
                bottom_left: "╰",
                bottom_right: "╯",
            },
            BorderStyle::Thick => BorderChars {
                top: "━",
                bottom: "━",
                left: "┃",
                right: "┃",
                top_left: "┏",
                top_right: "┓",
                bottom_left: "┗",
                bottom_right: "┛",
            },
            BorderStyle::Ascii => BorderChars {
                top: "-",
                bottom: "-",
                left: "|",
                right: "|",
                top_left: "+",
                top_right: "+",
                bottom_left: "+",
                bottom_right: "+",
            },
            BorderStyle::Custom(chars) => chars.clone(),
        }
    }
}

// --- Convenience constructors ---

impl Block {
    pub fn text(lines: Vec<Line>) -> Self {
        Block::Text(lines)
    }

    pub fn text_plain(content: &str) -> Self {
        let lines: Vec<Line> = content.split('\n').map(|s| vec![Span::plain(s)]).collect();
        Block::Text(lines)
    }

    pub fn empty(height: usize) -> Self {
        Block::Empty { height }
    }

    pub fn boxed(content: Block, border: BorderStyle, title: Option<Line>) -> Self {
        Block::Box {
            content: Box::new(content),
            border,
            title,
        }
    }

    pub fn hstack(children: Vec<Block>, gap: usize) -> Self {
        Block::HStack { children, gap }
    }

    pub fn vstack(children: Vec<Block>, gap: usize) -> Self {
        Block::VStack { children, gap }
    }

    pub fn sized(content: Block, min_width: Option<usize>, min_height: Option<usize>) -> Self {
        Block::Sized {
            content: Box::new(content),
            min_width,
            min_height,
        }
    }

    pub fn padded(content: Block, top: usize, bottom: usize, left: usize, right: usize) -> Self {
        Block::Padded {
            content: Box::new(content),
            top,
            bottom,
            left,
            right,
        }
    }

    // --- Measurement ---

    pub fn min_width(&self) -> usize {
        match self {
            Block::Text(lines) => lines.iter().map(style::measure_line).max().unwrap_or(0),
            Block::Box {
                content, border, ..
            } => match border {
                BorderStyle::NoBorder => content.min_width(),
                _ => content.min_width() + 2,
            },
            Block::HStack { children, gap } => {
                let n = children.len();
                let total_gap = if n > 1 { (n - 1) * gap } else { 0 };
                let widths_sum: usize = children.iter().map(|c| c.min_width()).sum();
                widths_sum + total_gap
            }
            Block::VStack { children, .. } => {
                children.iter().map(|c| c.min_width()).max().unwrap_or(0)
            }
            Block::Empty { .. } => 0,
            Block::Sized {
                content, min_width, ..
            } => content.min_width().max(min_width.unwrap_or(0)),
            Block::Padded {
                content,
                left,
                right,
                ..
            } => content.min_width() + left + right,
        }
    }

    pub fn height(&self) -> usize {
        match self {
            Block::Text(lines) => lines.len(),
            Block::Box {
                content, border, ..
            } => match border {
                BorderStyle::NoBorder => content.height(),
                _ => content.height() + 2,
            },
            Block::HStack { children, .. } => {
                children.iter().map(|c| c.height()).max().unwrap_or(0)
            }
            Block::VStack { children, gap } => {
                let n = children.len();
                let total_gap = if n > 1 { (n - 1) * gap } else { 0 };
                let heights_sum: usize = children.iter().map(|c| c.height()).sum();
                heights_sum + total_gap
            }
            Block::Empty { height } => *height,
            Block::Sized {
                content,
                min_height,
                ..
            } => content.height().max(min_height.unwrap_or(0)),
            Block::Padded {
                content,
                top,
                bottom,
                ..
            } => content.height() + top + bottom,
        }
    }

    // --- Rendering ---

    pub fn render(&self, width: usize) -> Vec<String> {
        match self {
            Block::Text(lines) => render_text_lines(lines, width),
            Block::Box {
                content,
                border,
                title,
            } => render_box(content, border, title.as_ref(), width),
            Block::HStack { children, gap } => render_hstack(children, *gap, width),
            Block::VStack { children, gap } => render_vstack(children, *gap, width),
            Block::Empty { height } => vec![blank_line(width); *height],
            Block::Sized {
                content,
                min_width,
                min_height,
            } => render_sized(content, *min_width, *min_height, width),
            Block::Padded {
                content,
                top,
                bottom,
                left,
                right,
            } => render_padded(content, *top, *bottom, *left, *right, width),
        }
    }
}

// --- Internal helpers ---

fn render_text_lines(lines: &[Line], width: usize) -> Vec<String> {
    lines
        .iter()
        .map(|line| {
            let truncated = style::truncate_line(line, width);
            let padded = style::pad_line(&truncated, width, Align::Left);
            style::render_line(&padded)
        })
        .collect()
}

fn render_box(
    content: &Block,
    border: &BorderStyle,
    title: Option<&Line>,
    width: usize,
) -> Vec<String> {
    match border {
        BorderStyle::NoBorder => content.render(width),
        _ => {
            let chars = border.chars();
            let inner_width = width.saturating_sub(2);
            let top = render_top_border(&chars, inner_width, title);
            let bottom = render_bottom_border(&chars, inner_width);
            let content_lines = content.render(inner_width);
            let mut result = vec![top];
            for line in &content_lines {
                result.push(format!("{}{}{}", chars.left, line, chars.right));
            }
            result.push(bottom);
            result
        }
    }
}

fn render_top_border(chars: &BorderChars, inner_width: usize, title: Option<&Line>) -> String {
    match title {
        None => format!(
            "{}{}{}",
            chars.top_left,
            chars.top.repeat(inner_width),
            chars.top_right
        ),
        Some(title_line) => {
            let available_for_title = inner_width.saturating_sub(4);
            if available_for_title == 0 {
                return format!(
                    "{}{}{}",
                    chars.top_left,
                    chars.top.repeat(inner_width),
                    chars.top_right
                );
            }
            let truncated = style::truncate_line(title_line, available_for_title);
            let title_str = style::render_line(&truncated);
            let title_visible_width = style::measure_line(&truncated);
            let left_deco = format!("{}{} ", chars.top, chars.top);
            let right_fill_width = inner_width.saturating_sub(3 + title_visible_width + 1);
            let right_deco = format!(" {}", chars.top.repeat(right_fill_width));
            format!(
                "{}{}{}{}{}",
                chars.top_left, left_deco, title_str, right_deco, chars.top_right
            )
        }
    }
}

fn render_bottom_border(chars: &BorderChars, inner_width: usize) -> String {
    format!(
        "{}{}{}",
        chars.bottom_left,
        chars.bottom.repeat(inner_width),
        chars.bottom_right
    )
}

fn render_hstack(children: &[Block], gap: usize, width: usize) -> Vec<String> {
    match children.len() {
        0 => vec![],
        1 => children[0].render(width),
        n => {
            let total_gap = (n - 1) * gap;
            let available = width.saturating_sub(total_gap);
            let base_width = available / n;
            let remainder = available % n;

            let widths: Vec<usize> = (0..n)
                .map(|i| {
                    if i == n - 1 {
                        base_width + remainder
                    } else {
                        base_width
                    }
                })
                .collect();

            let rendered: Vec<Vec<String>> = children
                .iter()
                .zip(widths.iter())
                .map(|(child, &w)| child.render(w))
                .collect();

            let max_height = rendered.iter().map(|r| r.len()).max().unwrap_or(0);

            let padded: Vec<Vec<String>> = rendered
                .into_iter()
                .zip(widths.iter())
                .map(|(mut col, &w)| {
                    while col.len() < max_height {
                        col.push(blank_line(w));
                    }
                    col
                })
                .collect();

            let gap_str = " ".repeat(gap);
            (0..max_height)
                .map(|row| {
                    padded
                        .iter()
                        .map(|col| col[row].as_str())
                        .collect::<Vec<_>>()
                        .join(&gap_str)
                })
                .collect()
        }
    }
}

fn render_vstack(children: &[Block], gap: usize, width: usize) -> Vec<String> {
    let gap_lines: Vec<String> = vec![blank_line(width); gap];
    let mut result = Vec::new();
    for (i, child) in children.iter().enumerate() {
        if i > 0 {
            result.extend(gap_lines.iter().cloned());
        }
        result.extend(child.render(width));
    }
    result
}

fn render_sized(
    content: &Block,
    min_width: Option<usize>,
    min_height: Option<usize>,
    width: usize,
) -> Vec<String> {
    let effective_width = width.max(min_width.unwrap_or(0));
    let mut lines = content.render(effective_width);
    let target_height = min_height.unwrap_or(0);
    while lines.len() < target_height {
        lines.push(blank_line(effective_width));
    }
    lines
}

fn render_padded(
    content: &Block,
    top: usize,
    bottom: usize,
    left: usize,
    right: usize,
    width: usize,
) -> Vec<String> {
    let inner_width = width.saturating_sub(left + right);
    let left_pad = " ".repeat(left);
    let right_pad = " ".repeat(right);
    let content_lines = content.render(inner_width);
    let mut result = Vec::new();
    // Top padding rows
    for _ in 0..top {
        result.push(blank_line(width));
    }
    for line in &content_lines {
        result.push(format!("{}{}{}", left_pad, line, right_pad));
    }
    // Bottom padding rows
    for _ in 0..bottom {
        result.push(blank_line(width));
    }
    result
}

fn blank_line(width: usize) -> String {
    " ".repeat(width)
}

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

    #[test]
    fn text_block_renders() {
        let block = Block::text(vec![vec![Span::plain("hello")], vec![Span::plain("world")]]);
        let lines = block.render(10);
        assert_eq!(lines.len(), 2);
        assert_eq!(lines[0].len(), 10); // padded to width
    }

    #[test]
    fn text_plain_splits_newlines() {
        let block = Block::text_plain("a\nb\nc");
        assert_eq!(block.height(), 3);
    }

    #[test]
    fn empty_block() {
        let block = Block::empty(3);
        let lines = block.render(5);
        assert_eq!(lines.len(), 3);
        assert!(lines.iter().all(|l| l == "     "));
    }

    #[test]
    fn box_single_border() {
        let inner = Block::text(vec![vec![Span::plain("hi")]]);
        let boxed = Block::boxed(inner, BorderStyle::Single, None);
        let lines = boxed.render(10);
        assert_eq!(lines.len(), 3); // top + content + bottom
        assert!(lines[0].starts_with('┌'));
        assert!(lines[2].starts_with('└'));
    }

    #[test]
    fn vstack_with_gap() {
        let a = Block::text(vec![vec![Span::plain("a")]]);
        let b = Block::text(vec![vec![Span::plain("b")]]);
        let stack = Block::vstack(vec![a, b], 1);
        let lines = stack.render(5);
        assert_eq!(lines.len(), 3); // a + gap + b
    }

    #[test]
    fn hstack_two_children() {
        let a = Block::text(vec![vec![Span::plain("L")]]);
        let b = Block::text(vec![vec![Span::plain("R")]]);
        let stack = Block::hstack(vec![a, b], 1);
        let lines = stack.render(11);
        assert_eq!(lines.len(), 1);
    }

    #[test]
    fn min_width_measurement() {
        let block = Block::text(vec![
            vec![Span::plain("short")],
            vec![Span::plain("longer text")],
        ]);
        assert_eq!(block.min_width(), 11);
    }

    #[test]
    fn height_measurement() {
        let block = Block::text(vec![
            vec![Span::plain("a")],
            vec![Span::plain("b")],
            vec![Span::plain("c")],
        ]);
        assert_eq!(block.height(), 3);
    }
}