unicode-plot 0.1.0

use crate::canvas::{AxisTransform, Canvas, CanvasCore, Scale, Transform2D};
use crate::color::CanvasColor;

const X_PIXELS_PER_CHAR: usize = 2;
const Y_PIXELS_PER_CHAR: usize = 4;
const BRAILLE_BASE: u32 = 0x2800;
const BRAILLE_BITS: [[u16; Y_PIXELS_PER_CHAR]; X_PIXELS_PER_CHAR] =
    [[0x01, 0x02, 0x04, 0x40], [0x08, 0x10, 0x20, 0x80]];
const BLANK_BRAILLE: char = '\u{2800}';

/// A 2x4 pixel-per-character canvas using Unicode braille patterns (U+2800..U+28FF).
#[derive(Debug, Clone, PartialEq)]
pub struct BrailleCanvas {
    core: CanvasCore<u16>,
}

impl BrailleCanvas {
    /// Creates a braille canvas with identity axis scales.
    ///
    /// # Panics
    ///
    /// Panics when either axis transform cannot be constructed. This occurs if
    /// plot spans are non-positive, pixel dimensions are zero, or origins are
    /// non-finite.
    #[must_use]
    pub fn new(
        char_width: usize,
        char_height: usize,
        origin_x: f64,
        origin_y: f64,
        plot_width: f64,
        plot_height: f64,
    ) -> Self {
        let pixel_width = char_width.saturating_mul(X_PIXELS_PER_CHAR);
        let pixel_height = char_height.saturating_mul(Y_PIXELS_PER_CHAR);
        let x = AxisTransform::new(origin_x, plot_width, pixel_width, Scale::Identity, false)
            .expect(
                "BrailleCanvas::new requires finite x-origin, positive span, and non-zero width",
            );
        let y = AxisTransform::new(origin_y, plot_height, pixel_height, Scale::Identity, true)
            .expect(
                "BrailleCanvas::new requires finite y-origin, positive span, and non-zero height",
            );

        Self {
            core: CanvasCore::new(
                char_width,
                char_height,
                pixel_width,
                pixel_height,
                Transform2D::new(x, y),
            ),
        }
    }

    #[must_use]
    #[cfg(test)]
    pub(crate) fn print_row(&self, row: usize, color: bool) -> String {
        if row >= self.char_height() {
            return String::new();
        }

        let mut out = String::new();
        for col in 0..self.char_width() {
            super::write_colored_cell(
                &mut out,
                self.glyph_at(col, row),
                self.color_at(col, row),
                color,
            );
        }

        out
    }

    #[must_use]
    #[cfg(test)]
    pub(crate) fn print(&self, color: bool) -> String {
        let mut out = String::new();
        for row in 0..self.char_height() {
            for col in 0..self.char_width() {
                super::write_colored_cell(
                    &mut out,
                    self.glyph_at(col, row),
                    self.color_at(col, row),
                    color,
                );
            }
            if row + 1 < self.char_height() {
                out.push('\n');
            }
        }

        out
    }

    fn cell_index(&self, col: usize, row: usize) -> Option<usize> {
        if col >= self.core.char_width || row >= self.core.char_height {
            return None;
        }

        Some(row * self.core.char_width + col)
    }
}

impl Canvas for BrailleCanvas {
    fn pixel(&mut self, x: usize, y: usize, color: CanvasColor) {
        if x > self.pixel_width() || y > self.pixel_height() {
            return;
        }

        let clamped_x = if x < self.pixel_width() {
            x
        } else {
            x.saturating_sub(1)
        };
        let clamped_y = if y < self.pixel_height() {
            y
        } else {
            y.saturating_sub(1)
        };

        let col = clamped_x / X_PIXELS_PER_CHAR;
        let row = clamped_y / Y_PIXELS_PER_CHAR;

        let x_off = clamped_x % X_PIXELS_PER_CHAR;
        let y_off = clamped_y % Y_PIXELS_PER_CHAR;

        let Some(index) = self.cell_index(col, row) else {
            return;
        };

        self.core.grid[index] |= BRAILLE_BITS[x_off][y_off];
        self.core.colors[index] |= color.as_u8();
    }

    fn glyph_at(&self, col: usize, row: usize) -> char {
        let Some(index) = self.cell_index(col, row) else {
            return BLANK_BRAILLE;
        };

        char::from_u32(BRAILLE_BASE + u32::from(self.core.grid[index])).unwrap_or(BLANK_BRAILLE)
    }

    fn color_at(&self, col: usize, row: usize) -> CanvasColor {
        self.cell_index(col, row)
            .and_then(|index| CanvasColor::new(self.core.colors[index]))
            .unwrap_or(CanvasColor::NORMAL)
    }

    fn char_width(&self) -> usize {
        self.core.char_width
    }

    fn char_height(&self) -> usize {
        self.core.char_height
    }

    fn pixel_width(&self) -> usize {
        self.core.pixel_width
    }

    fn pixel_height(&self) -> usize {
        self.core.pixel_height
    }

    fn transform(&self) -> &Transform2D {
        &self.core.transform
    }

    fn transform_mut(&mut self) -> &mut Transform2D {
        &mut self.core.transform
    }
}

#[cfg(test)]
mod tests {
    use super::BrailleCanvas;
    use crate::canvas::{Canvas, draw_reference_canvas_scene, render_canvas_show};
    use crate::color::CanvasColor;
    use crate::test_util::assert_fixture_eq;

    fn fixture_canvas() -> BrailleCanvas {
        let mut canvas = BrailleCanvas::new(40, 10, 0.0, 0.0, 1.0, 1.0);
        draw_reference_canvas_scene(&mut canvas);
        canvas
    }

    #[test]
    fn braille_glyph_encoding_matches_reference_bit_positions() {
        let mut canvas = BrailleCanvas::new(1, 1, 0.0, 0.0, 1.0, 1.0);
        canvas.pixel(0, 0, CanvasColor::BLUE);
        canvas.pixel(0, 1, CanvasColor::BLUE);
        canvas.pixel(0, 2, CanvasColor::BLUE);
        canvas.pixel(0, 3, CanvasColor::BLUE);
        canvas.pixel(1, 0, CanvasColor::BLUE);
        canvas.pixel(1, 1, CanvasColor::BLUE);
        canvas.pixel(1, 2, CanvasColor::BLUE);
        canvas.pixel(1, 3, CanvasColor::BLUE);

        assert_eq!(canvas.glyph_at(0, 0), '⣿');
        assert_eq!(canvas.color_at(0, 0), CanvasColor::BLUE);
    }

    #[test]
    fn braille_single_dot_encoding_matches_unicode_bit_table() {
        let cases = [
            (0, 0, '\u{2801}'),
            (0, 1, '\u{2802}'),
            (0, 2, '\u{2804}'),
            (0, 3, '\u{2840}'),
            (1, 0, '\u{2808}'),
            (1, 1, '\u{2810}'),
            (1, 2, '\u{2820}'),
            (1, 3, '\u{2880}'),
        ];

        for (x, y, expected) in cases {
            let mut canvas = BrailleCanvas::new(1, 1, 0.0, 0.0, 1.0, 1.0);
            canvas.pixel(x, y, CanvasColor::GREEN);
            assert_eq!(canvas.glyph_at(0, 0), expected);
        }
    }

    #[test]
    fn pixel_ors_color_bits_when_multiple_series_overlap() {
        let mut canvas = BrailleCanvas::new(1, 1, 0.0, 0.0, 1.0, 1.0);
        canvas.pixel(0, 0, CanvasColor::BLUE);
        canvas.pixel(0, 0, CanvasColor::RED);
        assert_eq!(canvas.color_at(0, 0), CanvasColor::MAGENTA);

        canvas.pixel(0, 0, CanvasColor::WHITE);
        assert_eq!(canvas.color_at(0, 0), CanvasColor::WHITE);
    }

    #[test]
    fn print_row_matches_fixture() {
        let canvas = fixture_canvas();
        let actual = canvas.print_row(2, true);

        assert_fixture_eq(&actual, "tests/fixtures/canvas/braille_printrow.txt");
    }

    #[test]
    fn print_matches_fixture_with_color() {
        let canvas = fixture_canvas();
        let actual = canvas.print(true);

        assert_fixture_eq(&actual, "tests/fixtures/canvas/braille_print.txt");
    }

    #[test]
    fn print_matches_fixture_without_color() {
        let canvas = fixture_canvas();
        let actual = canvas.print(false);

        assert_fixture_eq(&actual, "tests/fixtures/canvas/braille_print_nocolor.txt");
    }

    #[test]
    fn show_matches_fixture_with_color() {
        let canvas = fixture_canvas();
        let actual = render_canvas_show(canvas, true);

        assert_fixture_eq(&actual, "tests/fixtures/canvas/braille_show.txt");
    }

    #[test]
    fn show_matches_fixture_without_color() {
        let canvas = fixture_canvas();
        let actual = render_canvas_show(canvas, false);

        assert_fixture_eq(&actual, "tests/fixtures/canvas/braille_show_nocolor.txt");
    }

    #[test]
    fn show_empty_canvas_matches_fixture() {
        let canvas = BrailleCanvas::new(40, 10, 0.0, 0.0, 1.0, 1.0);
        let actual = render_canvas_show(canvas, true);

        assert_fixture_eq(&actual, "tests/fixtures/canvas/empty_braille_show.txt");
    }
}