tui_splitflap/

state.rs

//! Board-level animation state and message API.

use crate::CharSet;
use crate::cell::{FlapCell, FlipStyle};

/// A message to display on the board, with optional per-message overrides.
#[derive(Debug, Clone)]
pub struct FlapMessage {
    pub rows: Vec<String>,
    pub flip_speed_ms: Option<u64>,
}

impl FlapMessage {
    pub fn single(text: impl Into<String>) -> Self {
        Self {
            rows: vec![text.into()],
            flip_speed_ms: None,
        }
    }

    pub fn multi(rows: impl IntoIterator<Item = impl Into<String>>) -> Self {
        Self {
            rows: rows.into_iter().map(Into::into).collect(),
            flip_speed_ms: None,
        }
    }

    pub fn with_flip_speed(mut self, ms: u64) -> Self {
        self.flip_speed_ms = Some(ms);
        self
    }
}

/// Owns all per-cell animation state for a split-flap board.
/// Driven externally via `tick()` and `set_message()`.
#[derive(Debug, Clone)]
pub struct FlapBoardState {
    cells: Vec<Vec<FlapCell>>,
    charset: CharSet,
    flip_style: FlipStyle,
    flip_speed_ms: u64,
    stagger_ms: u64,
}

impl FlapBoardState {
    pub fn new(rows: usize, cols: usize) -> Self {
        let cells = (0..rows)
            .map(|_| (0..cols).map(|_| FlapCell::new(' ')).collect())
            .collect();

        Self {
            cells,
            charset: CharSet::default(),
            flip_style: FlipStyle::Sequential,
            flip_speed_ms: 80,
            stagger_ms: 0,
        }
    }

    pub fn with_charset(mut self, charset: CharSet) -> Self {
        self.charset = charset;
        self
    }

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

    pub fn with_flip_speed_ms(mut self, ms: u64) -> Self {
        self.flip_speed_ms = ms;
        self
    }

    pub fn with_stagger_ms(mut self, ms: u64) -> Self {
        self.stagger_ms = ms;
        self
    }

    /// Stagger is column-only: each column's pending delay is `col_idx * stagger_ms`.
    /// In multi-row boards, all rows begin simultaneously.
    #[must_use]
    pub fn tick(&mut self, delta_ms: u64) -> bool {
        let mut any_animating = false;

        for row in &mut self.cells {
            for cell in row {
                if cell.tick(delta_ms, &self.charset) {
                    any_animating = true;
                }
            }
        }

        any_animating
    }

    pub fn set_message(&mut self, msg: &FlapMessage) {
        let speed = msg.flip_speed_ms.unwrap_or(self.flip_speed_ms);

        for (row_idx, row) in self.cells.iter_mut().enumerate() {
            let text = msg.rows.get(row_idx).map(|s| s.as_str()).unwrap_or("");
            let mut chars = text.chars();

            for (col_idx, cell) in row.iter_mut().enumerate() {
                let target = chars.next().unwrap_or(' ');
                let pending = col_idx as u64 * self.stagger_ms;

                cell.set_target(target, self.flip_style, &self.charset, speed, pending);
            }
        }
    }

    pub fn reset(&mut self) {
        for row in &mut self.cells {
            for cell in row {
                cell.reset(' ');
            }
        }
    }

    pub fn cell(&self, row: usize, col: usize) -> Option<&FlapCell> {
        self.cells.get(row).and_then(|r| r.get(col))
    }

    pub fn rows(&self) -> usize {
        self.cells.len()
    }

    pub fn cols(&self) -> usize {
        self.cells.first().map_or(0, |r| r.len())
    }

    pub fn charset(&self) -> &CharSet {
        &self.charset
    }

    pub fn flip_style(&self) -> FlipStyle {
        self.flip_style
    }
}

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

    fn board(rows: usize, cols: usize) -> FlapBoardState {
        FlapBoardState::new(rows, cols)
    }

    fn settled_board(text: &str, cols: usize) -> FlapBoardState {
        let mut b = board(1, cols).with_flip_speed_ms(80);
        b.set_message(&FlapMessage::single(text));

        // Default charset has 56 chars; max distance is 55 steps × 80ms = 4400ms
        let _ = b.tick(55 * 80);
        b
    }

    fn cell_at(b: &FlapBoardState, row: usize, col: usize) -> &FlapCell {
        b.cell(row, col).expect("cell should exist at row, col")
    }

    fn display_string(b: &FlapBoardState, row: usize) -> String {
        (0..b.cols())
            .map(|c| cell_at(b, row, c).display())
            .collect()
    }

    // --- Tick ---

    #[test]
    fn tick_advances_animating_cells() {
        let mut b = board(1, 5).with_flip_speed_ms(80);
        b.set_message(&FlapMessage::single("ABCDE"));

        let _ = b.tick(40);

        for col in 0..5 {
            let p = cell_at(&b, 0, col).progress();
            assert!(p > 0.0, "col {col} should have advanced");
        }
    }

    #[test]
    fn tick_completes_cells() {
        let mut b = board(1, 3).with_flip_speed_ms(80);
        b.set_message(&FlapMessage::single("AAA"));

        // Space→A is distance 1, total = 80ms
        let _ = b.tick(80);

        for col in 0..3 {
            assert!(!cell_at(&b, 0, col).is_animating());
            assert_eq!(cell_at(&b, 0, col).display(), 'A');
        }
    }

    #[test]
    fn tick_zero_is_noop() {
        let mut b = board(1, 3).with_flip_speed_ms(80);
        b.set_message(&FlapMessage::single("ABC"));

        let before: Vec<f32> = (0..3).map(|c| cell_at(&b, 0, c).progress()).collect();
        let _ = b.tick(0);
        let after: Vec<f32> = (0..3).map(|c| cell_at(&b, 0, c).progress()).collect();

        assert_eq!(before, after);
    }

    #[test]
    fn tick_returns_animating_status() {
        let mut b = board(1, 1).with_flip_speed_ms(80);
        b.set_message(&FlapMessage::single("A"));

        assert!(b.tick(40));
        assert!(!b.tick(80));
    }

    // --- set_message ---

    #[test]
    fn only_changed_cells_animate() {
        let mut b = settled_board("HELLO", 10);

        b.set_message(&FlapMessage::single("HALLO"));

        // H unchanged, E→A changed, L unchanged twice, O unchanged
        assert!(!cell_at(&b, 0, 0).is_animating(), "H→H should not animate");
        assert!(cell_at(&b, 0, 1).is_animating(), "E→A should animate");
        assert!(!cell_at(&b, 0, 2).is_animating(), "L→L should not animate");
        assert!(!cell_at(&b, 0, 3).is_animating(), "L→L should not animate");
        assert!(!cell_at(&b, 0, 4).is_animating(), "O→O should not animate");
    }

    #[test]
    fn short_message_pads_with_spaces() {
        let mut b = settled_board("HELLO", 10);

        b.set_message(&FlapMessage::single("HI"));

        assert_eq!(cell_at(&b, 0, 0).target(), 'H');
        assert_eq!(cell_at(&b, 0, 1).target(), 'I');

        // Remaining cells should target space
        for col in 2..10 {
            let cell = cell_at(&b, 0, col);

            if cell.is_animating() {
                assert_eq!(cell.target(), ' ', "col {col} should target space");
            } else {
                assert_eq!(cell.display(), ' ', "col {col} should display space");
            }
        }
    }

    #[test]
    fn message_truncated_to_board_width() {
        let mut b = board(1, 3).with_flip_speed_ms(80);
        b.set_message(&FlapMessage::single("ABCDEF"));

        // Only first 3 chars should be set
        let _ = b.tick(10000);
        assert_eq!(display_string(&b, 0), "ABC");
    }

    // --- Stagger ---

    #[test]
    fn stagger_offsets_cell_start_times() {
        let mut b = board(1, 5).with_flip_speed_ms(80).with_stagger_ms(20);
        b.set_message(&FlapMessage::single("ABCDE"));

        // At t=0, all cells are pending except col 0
        assert_eq!(cell_at(&b, 0, 0).phase(), FlipPhase::Sequential);
        assert_eq!(cell_at(&b, 0, 1).phase(), FlipPhase::Pending);
        assert_eq!(cell_at(&b, 0, 4).phase(), FlipPhase::Pending);

        // After 20ms, col 0 has been animating for 20ms, col 1 just started
        let _ = b.tick(20);
        assert_eq!(cell_at(&b, 0, 1).phase(), FlipPhase::Sequential);
        assert_eq!(cell_at(&b, 0, 2).phase(), FlipPhase::Pending);
    }

    #[test]
    fn stagger_zero_all_simultaneous() {
        let mut b = board(1, 5).with_flip_speed_ms(80).with_stagger_ms(0);
        b.set_message(&FlapMessage::single("ABCDE"));

        for col in 0..5 {
            assert_ne!(
                cell_at(&b, 0, col).phase(),
                FlipPhase::Pending,
                "col {col} should not be pending with stagger=0"
            );
        }
    }

    // --- Multi-row ---

    #[test]
    fn multi_row_maps_message_rows_to_cell_rows() {
        let mut b = board(2, 10).with_flip_speed_ms(80);
        b.set_message(&FlapMessage::multi(["DEPARTING ", "GATE 7B   "]));

        let _ = b.tick(10000);
        assert_eq!(display_string(&b, 0), "DEPARTING ");
        assert_eq!(display_string(&b, 1), "GATE 7B   ");
    }

    #[test]
    fn rows_animate_independently() {
        let mut b = board(2, 5).with_flip_speed_ms(80);

        // Row 0: space→A (distance 1, 80ms), Row 1: space→Z (distance 26, 2080ms)
        b.set_message(&FlapMessage::multi(["AAAAA", "ZZZZZ"]));

        let _ = b.tick(80);

        // Row 0 should be done
        for col in 0..5 {
            assert!(
                !cell_at(&b, 0, col).is_animating(),
                "row 0 col {col} should be settled"
            );
        }

        // Row 1 should still be animating
        for col in 0..5 {
            assert!(
                cell_at(&b, 1, col).is_animating(),
                "row 1 col {col} should still animate"
            );
        }
    }

    #[test]
    fn missing_message_rows_pad_with_spaces() {
        let mut b = board(2, 5).with_flip_speed_ms(80);

        // Only one row of text for a 2-row board
        b.set_message(&FlapMessage::single("HELLO"));

        let _ = b.tick(10000);
        assert_eq!(display_string(&b, 0), "HELLO");
        assert_eq!(display_string(&b, 1), "     ");
    }

    // --- Reset ---

    #[test]
    fn reset_clears_all_cells() {
        let mut b = settled_board("HELLO", 10);

        b.reset();

        for col in 0..10 {
            let cell = cell_at(&b, 0, col);
            assert_eq!(cell.display(), ' ');
            assert_eq!(cell.settled(), ' ');
            assert!(!cell.is_animating());
            assert_eq!(cell.progress(), 0.0);
        }
    }

    #[test]
    fn reset_stops_in_flight_animation() {
        let mut b = board(1, 5).with_flip_speed_ms(80);
        b.set_message(&FlapMessage::single("HELLO"));
        let _ = b.tick(20);

        b.reset();

        assert!(!b.tick(0));

        for col in 0..5 {
            assert!(!cell_at(&b, 0, col).is_animating());
        }
    }

    // --- Per-message speed override ---

    #[test]
    fn message_speed_override() {
        let mut b = board(1, 1).with_flip_speed_ms(80);

        // Space→A distance 1, with override speed 200ms
        b.set_message(&FlapMessage::single("A").with_flip_speed(200));

        // At 80ms (default speed), should still be animating
        assert!(b.tick(80));

        // At 200ms total, should complete
        assert!(!b.tick(120));
        assert_eq!(cell_at(&b, 0, 0).display(), 'A');
    }
}