tui_splitflap/

widget.rs

//! Stateless `FlapBoard` widget and cell rendering.

use ratatui::buffer::Buffer;
use ratatui::layout::Rect;
use ratatui::style::Style;
use ratatui::widgets::{Block, StatefulWidget, Widget};

use crate::cell::FlipPhase;
use crate::state::FlapBoardState;
use crate::theme::FlapTheme;

#[cfg(feature = "pantry")]
#[path = "widget.ingredient.rs"]
pub mod ingredient;

const CELL_HEIGHT: u16 = 3;

/// Terminal columns per tile.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CellWidth {
    #[default]
    Normal,
    Compact,
}

impl CellWidth {
    pub fn columns(self) -> u16 {
        match self {
            CellWidth::Normal => 3,
            CellWidth::Compact => 1,
        }
    }
}

/// Stateless widget that renders a split-flap board from `FlapBoardState`.
#[derive(Debug, Clone, Default)]
pub struct FlapBoard<'a> {
    cell_width: CellWidth,
    theme: FlapTheme,
    block: Option<Block<'a>>,
}

impl<'a> FlapBoard<'a> {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn cell_width(mut self, width: CellWidth) -> Self {
        self.cell_width = width;
        self
    }

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

    pub fn block(mut self, block: Block<'a>) -> Self {
        self.block = Some(block);
        self
    }
}

impl StatefulWidget for FlapBoard<'_> {
    type State = FlapBoardState;

    fn render(self, area: Rect, buf: &mut Buffer, state: &mut FlapBoardState) {
        let area = area.intersection(*buf.area());
        fill_background(buf, area, self.theme.board_style());

        let inner = render_block(self.block, area, buf);

        if inner.width == 0 || inner.height == 0 {
            return;
        }

        let cw = self.cell_width.columns();
        let visible_cols = (inner.width / cw) as usize;
        let visible_rows = (inner.height / CELL_HEIGHT) as usize;

        if visible_cols == 0 || visible_rows == 0 {
            return;
        }

        let render_cols = visible_cols.min(state.cols());
        let render_rows = visible_rows.min(state.rows());

        let board_width = render_cols as u16 * cw;
        let board_height = render_rows as u16 * CELL_HEIGHT;
        let x_offset = inner.x + (inner.width.saturating_sub(board_width)) / 2;
        let y_offset = inner.y + (inner.height.saturating_sub(board_height)) / 2;

        for row in 0..render_rows {
            for col in 0..render_cols {
                let Some(cell) = state.cell(row, col) else {
                    continue;
                };

                let x = x_offset + col as u16 * cw;
                let y = y_offset + row as u16 * CELL_HEIGHT;

                render_cell(
                    buf,
                    Rect::new(x, y, cw, CELL_HEIGHT),
                    cell,
                    &self.cell_width,
                    &self.theme,
                );
            }
        }
    }
}

fn fill_background(buf: &mut Buffer, area: Rect, style: Style) {
    for y in area.top()..area.bottom() {
        for x in area.left()..area.right() {
            buf[(x, y)].set_style(style);
        }
    }
}

fn render_block(block: Option<Block<'_>>, area: Rect, buf: &mut Buffer) -> Rect {
    match block {
        Some(b) => {
            let inner = b.inner(area);
            b.render(area, buf);
            inner
        }
        None => area,
    }
}

fn render_cell(
    buf: &mut Buffer,
    area: Rect,
    cell: &crate::cell::FlapCell,
    cell_width: &CellWidth,
    theme: &FlapTheme,
) {
    for y in area.top()..area.bottom() {
        for x in area.left()..area.right() {
            buf[(x, y)].set_style(theme.tile_style());
        }
    }

    if *cell_width == CellWidth::Normal {
        render_cell_border(buf, area, theme);
    }

    match cell.phase() {
        FlipPhase::Settled | FlipPhase::Sequential | FlipPhase::Pending => {
            render_char_cell(buf, area, cell.display(), cell_width, theme);
        }

        FlipPhase::Mechanical {
            frame,
            total_frames,
        } => {
            render_mechanical_cell(buf, area, cell, cell_width, theme, frame, total_frames);
        }
    }
}

fn render_cell_border(buf: &mut Buffer, area: Rect, theme: &FlapTheme) {
    let style = theme.border_style();
    let x0 = area.x;
    let x2 = area.x + 2;
    let y0 = area.y;
    let y2 = area.y + 2;

    buf[(x0, y0)].set_char('┌').set_style(style);
    buf[(x0 + 1, y0)].set_char('─').set_style(style);
    buf[(x2, y0)].set_char('┐').set_style(style);

    buf[(x0, y0 + 1)].set_char('│').set_style(style);
    buf[(x2, y0 + 1)].set_char('│').set_style(style);

    buf[(x0, y2)].set_char('└').set_style(style);
    buf[(x0 + 1, y2)].set_char('─').set_style(style);
    buf[(x2, y2)].set_char('┘').set_style(style);
}

fn render_char_cell(
    buf: &mut Buffer,
    area: Rect,
    ch: char,
    cell_width: &CellWidth,
    theme: &FlapTheme,
) {
    let char_x = char_column(area, cell_width);

    buf[(char_x, area.y + 1)]
        .set_char(ch)
        .set_style(theme.char_style());
}

fn render_mechanical_cell(
    buf: &mut Buffer,
    area: Rect,
    cell: &crate::cell::FlapCell,
    cell_width: &CellWidth,
    theme: &FlapTheme,
    frame: u8,
    total_frames: u8,
) {
    let stage = split_stage(frame, total_frames);
    let char_x = char_column(area, cell_width);
    let center_y = area.y + 1;

    let (split_char, top_char, bottom_char) = match stage {
        SplitStage::Closing => ('▄', Some(cell.settled()), None),
        SplitStage::Occluded => ('█', None, None),
        SplitStage::Opening => ('▀', None, Some(cell.target())),
    };

    buf[(char_x, center_y)]
        .set_char(split_char)
        .set_style(theme.split_style());

    if let Some(ch) = top_char {
        buf[(char_x, area.y)]
            .set_char(ch)
            .set_style(theme.char_style());
    }

    if let Some(ch) = bottom_char {
        buf[(char_x, area.y + 2)]
            .set_char(ch)
            .set_style(theme.char_style());
    }
}

fn char_column(area: Rect, cell_width: &CellWidth) -> u16 {
    match cell_width {
        CellWidth::Normal => area.x + 1,
        CellWidth::Compact => area.x,
    }
}

#[derive(Debug, Clone, Copy)]
enum SplitStage {
    Closing,
    Occluded,
    Opening,
}

fn split_stage(frame: u8, total_frames: u8) -> SplitStage {
    if total_frames <= 1 {
        return SplitStage::Occluded;
    }

    let third = (total_frames / 3).max(1);

    if frame < third {
        SplitStage::Closing
    } else if frame >= total_frames - third {
        SplitStage::Opening
    } else {
        SplitStage::Occluded
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::cell::FlipStyle;
    use crate::state::FlapMessage;

    fn render_to_buffer(
        widget: FlapBoard,
        state: &mut FlapBoardState,
        width: u16,
        height: u16,
    ) -> Buffer {
        let area = Rect::new(0, 0, width, height);
        let mut buf = Buffer::empty(area);
        widget.render(area, &mut buf, state);
        buf
    }

    #[test]
    fn settled_board_renders_characters() {
        let mut state = FlapBoardState::new(1, 5).with_flip_speed_ms(80);
        state.set_message(&FlapMessage::single("HELLO"));
        let _ = state.tick(10000);

        let buf = render_to_buffer(FlapBoard::new(), &mut state, 80, 24);

        // No block → inner = full area (80×24). render_cols=5, board_width=15
        // x_offset = (80-15)/2 = 32, y_offset = (24-3)/2 = 10
        // center row = 10 + 1 = 11, char at center of 3-wide cell = x+1
        let x_off: u16 = 32;
        let y_center: u16 = 11;

        let chars: Vec<char> = (0..5)
            .map(|i| {
                let x = x_off + 1 + i * 3;
                buf[(x, y_center)].symbol().chars().next().unwrap_or('?')
            })
            .collect();

        assert_eq!(chars, vec!['H', 'E', 'L', 'L', 'O']);
    }

    #[test]
    fn cell_borders_rendered() {
        let mut state = FlapBoardState::new(1, 1).with_flip_speed_ms(80);
        state.set_message(&FlapMessage::single("A"));
        let _ = state.tick(10000);

        let buf = render_to_buffer(FlapBoard::new(), &mut state, 10, 5);

        // board: 3×3, centered in 10×5 → x_offset=3, y_offset=1
        assert_eq!(buf[(3, 1)].symbol(), "┌");
        assert_eq!(buf[(4, 1)].symbol(), "─");
        assert_eq!(buf[(5, 1)].symbol(), "┐");
        assert_eq!(buf[(3, 2)].symbol(), "│");
        assert_eq!(buf[(4, 2)].symbol(), "A");
        assert_eq!(buf[(5, 2)].symbol(), "│");
        assert_eq!(buf[(3, 3)].symbol(), "└");
        assert_eq!(buf[(4, 3)].symbol(), "─");
        assert_eq!(buf[(5, 3)].symbol(), "┘");
    }

    #[test]
    fn block_provides_container() {
        let mut state = FlapBoardState::new(1, 1);

        let widget = FlapBoard::new().block(Block::bordered().title(" Test "));
        let buf = render_to_buffer(widget, &mut state, 10, 5);

        // Block border at edges, inner area for cells
        assert_eq!(buf[(0, 0)].symbol(), "┌");
        assert_eq!(buf[(9, 4)].symbol(), "┘");
    }

    #[test]
    fn layout_computes_visible_cells() {
        let mut state = FlapBoardState::new(7, 26);
        let buf = render_to_buffer(FlapBoard::new(), &mut state, 80, 24);
        assert_eq!(buf.area().width, 80);
    }

    #[test]
    fn too_small_area_renders_nothing() {
        let mut state = FlapBoardState::new(1, 5);
        let buf = render_to_buffer(FlapBoard::new(), &mut state, 2, 2);
        assert_eq!(buf.area().width, 2);
    }

    #[test]
    fn compact_width_renders_without_borders() {
        let mut state = FlapBoardState::new(1, 5).with_flip_speed_ms(80);
        state.set_message(&FlapMessage::single("HELLO"));
        let _ = state.tick(10000);

        let widget = FlapBoard::new().cell_width(CellWidth::Compact);
        let buf = render_to_buffer(widget, &mut state, 20, 5);

        // No block → inner = 20×5. board: 5×3
        // x_offset = (20-5)/2 = 7, y_offset = (5-3)/2 = 1
        // center_y = 1 + 1 = 2
        let chars: Vec<char> = (0..5)
            .map(|i| {
                let x = 7 + i;
                buf[(x as u16, 2)].symbol().chars().next().unwrap_or('?')
            })
            .collect();

        assert_eq!(chars, vec!['H', 'E', 'L', 'L', 'O']);
    }

    #[test]
    fn mechanical_animation_renders_block_char() {
        let mut state = FlapBoardState::new(1, 1)
            .with_flip_speed_ms(80)
            .with_flip_style(FlipStyle::Mechanical { frames: 3 });

        state.set_message(&FlapMessage::single("Z"));

        // No block → inner = 10×5. board: 3×3
        // x_offset = (10-3)/2 = 3, y_offset = (5-3)/2 = 1
        // center_y = 2, char_x = 3+1 = 4
        let buf = render_to_buffer(FlapBoard::new(), &mut state, 10, 5);

        let center_char = buf[(4, 2)].symbol().chars().next().unwrap_or('?');
        assert_eq!(center_char, '▄');
    }

    #[test]
    fn board_centers_in_available_space() {
        let mut state = FlapBoardState::new(1, 2);
        // 2 cells × 3 wide = 6 board width, 3 board height
        // No block → inner = 20×5. x_offset = (20-6)/2 = 7, y_offset = (5-3)/2 = 1
        let buf = render_to_buffer(FlapBoard::new(), &mut state, 20, 5);

        let theme = FlapTheme::default();

        assert_eq!(buf[(7, 2)].bg, theme.tile_bg);
        assert_eq!(buf[(12, 2)].bg, theme.tile_bg);

        assert_eq!(buf[(6, 2)].bg, theme.bg);
        assert_eq!(buf[(13, 2)].bg, theme.bg);
    }
}