kronos_tide/

terminal.rs

use crate::unicode::char_width;

pub struct TerminalBuffer {
    cells: Vec<Vec<Cell>>,
    cursor_row: usize,
    cursor_col: usize,
    rows: usize,
    cols: usize,
    scrollback: Vec<Vec<Cell>>,
    max_scrollback: usize,
    /// DECSTBM scroll region: (top_row, bottom_row) inclusive, 0-indexed.
    scroll_top: usize,
    scroll_bottom: usize,
    /// Window title set by OSC 0/1/2.
    pub window_title: String,
}

#[derive(Clone, Debug)]
pub struct Cell {
    pub ch: char,
    pub fg: Color,
    pub bg: Color,
    pub bold: bool,
    pub italic: bool,
    pub underline: bool,
    /// True when this cell is the right half of a wide (width-2) character.
    /// The renderer should skip printing and the cell ch is set to ' '.
    pub wide_continuation: bool,
    /// Combining characters layered on top of this cell (e.g. accents).
    pub combining: Vec<char>,
}

#[derive(Clone, Debug, Copy)]
pub struct Color {
    pub r: u8,
    pub g: u8,
    pub b: u8,
}

impl Color {
    pub const WHITE: Self = Self {
        r: 255,
        g: 255,
        b: 255,
    };
    pub const BLACK: Self = Self { r: 0, g: 0, b: 0 };
    pub const fn rgb(r: u8, g: u8, b: u8) -> Self {
        Self { r, g, b }
    }

    pub fn from_ansi(code: u8) -> Self {
        match code {
            0 => Self::rgb(0, 0, 0),
            1 => Self::rgb(205, 49, 49),
            2 => Self::rgb(13, 188, 121),
            3 => Self::rgb(229, 229, 16),
            4 => Self::rgb(36, 114, 200),
            5 => Self::rgb(188, 63, 188),
            6 => Self::rgb(17, 168, 205),
            7 => Self::rgb(229, 229, 229),
            8 => Self::rgb(102, 102, 102),
            9 => Self::rgb(241, 76, 76),
            10 => Self::rgb(35, 209, 139),
            11 => Self::rgb(245, 245, 67),
            12 => Self::rgb(59, 142, 234),
            13 => Self::rgb(214, 112, 214),
            14 => Self::rgb(41, 184, 219),
            15 => Self::rgb(255, 255, 255),
            16..=231 => {
                let idx = code - 16;
                let r = (idx / 36) * 51;
                let g = ((idx % 36) / 6) * 51;
                let b = (idx % 6) * 51;
                Self::rgb(r, g, b)
            }
            232..=255 => {
                let gray = 8 + (code - 232) * 10;
                Self::rgb(gray, gray, gray)
            }
        }
    }
}

impl Default for Cell {
    fn default() -> Self {
        Self {
            ch: ' ',
            fg: Color::WHITE,
            bg: Color::BLACK,
            bold: false,
            italic: false,
            underline: false,
            wide_continuation: false,
            combining: Vec::new(),
        }
    }
}

impl TerminalBuffer {
    pub fn new(rows: usize, cols: usize, max_scrollback: usize) -> Self {
        let scroll_bottom = rows.saturating_sub(1);
        Self {
            cells: vec![vec![Cell::default(); cols]; rows],
            cursor_row: 0,
            cursor_col: 0,
            rows,
            cols,
            scrollback: Vec::new(),
            max_scrollback,
            scroll_top: 0,
            scroll_bottom,
            window_title: String::new(),
        }
    }

    /// Write a single character, applying Unicode width rules.
    ///
    /// - Width-0 (combining): appended to the previous cell's combining stack.
    /// - Width-1: normal single-column write.
    /// - Width-2 (wide): occupies current column (left half) and marks column+1
    ///   as a wide_continuation cell.  If only one column remains on the line the
    ///   wide character is rendered in the last column and no continuation is written
    ///   (truncation — simplest safe choice; the alternative is wrapping half-chars).
    pub fn write_char(&mut self, ch: char) {
        match ch {
            '\n' => {
                self.cursor_col = 0;
                self.advance_row();
            }
            '\r' => {
                self.cursor_col = 0;
            }
            '\x08' => {
                if self.cursor_col > 0 {
                    self.cursor_col -= 1;
                }
            }
            '\t' => {
                let next_tab = (self.cursor_col / 8 + 1) * 8;
                self.cursor_col = next_tab.min(self.cols - 1);
            }
            _ => {
                let w = char_width(ch);
                match w {
                    0 => self.write_combining(ch),
                    1 => self.write_normal(ch),
                    2 => self.write_wide(ch),
                    _ => self.write_normal(ch), // unknown width → treat as 1
                }
            }
        }
    }

    fn write_combining(&mut self, ch: char) {
        // Append combining char to the cell immediately before the cursor.
        // If cursor is at column 0 with no previous cell, silently drop it.
        if self.cursor_col > 0 {
            let col = self.cursor_col - 1;
            let row = self.cursor_row;
            if row < self.rows && col < self.cols {
                self.cells[row][col].combining.push(ch);
            }
        }
        // cursor does not advance for combining marks
    }

    fn write_normal(&mut self, ch: char) {
        if self.cursor_col >= self.cols {
            self.cursor_col = 0;
            self.advance_row();
        }
        let (row, col) = (self.cursor_row, self.cursor_col);
        if row < self.rows && col < self.cols {
            self.cells[row][col].ch = ch;
            self.cells[row][col].wide_continuation = false;
            self.cells[row][col].combining.clear();
        }
        self.cursor_col += 1;
    }

    fn write_wide(&mut self, ch: char) {
        // Need two columns.  If only one remains, truncate to last column.
        if self.cursor_col >= self.cols {
            self.cursor_col = 0;
            self.advance_row();
        }
        let (row, col) = (self.cursor_row, self.cursor_col);
        if row < self.rows && col < self.cols {
            self.cells[row][col].ch = ch;
            self.cells[row][col].wide_continuation = false;
            self.cells[row][col].combining.clear();
        }
        if col + 1 < self.cols {
            // Mark the right half as continuation so the renderer skips it.
            self.cells[row][col + 1] = Cell {
                ch: ' ',
                wide_continuation: true,
                ..Cell::default()
            };
            self.cursor_col += 2;
        } else {
            // Truncation: wide char placed in last column, no continuation cell.
            self.cursor_col += 1;
        }
    }

    /// Advance one row within the current scroll region, scrolling if needed.
    fn advance_row(&mut self) {
        if self.cursor_row >= self.scroll_bottom {
            self.scroll_region_up(1);
            // cursor stays at scroll_bottom after scroll
            self.cursor_row = self.scroll_bottom;
        } else {
            self.cursor_row += 1;
        }
    }

    /// Scroll the active scroll region up by `n` lines.
    /// Displaced top lines move to the scrollback buffer.
    pub fn scroll_up(&mut self) {
        self.scroll_region_up(1);
    }

    /// Scroll the scroll region up by `n` lines (CSI Ps S).
    pub fn scroll_region_up(&mut self, n: usize) {
        let top = self.scroll_top;
        let bot = self.scroll_bottom.min(self.rows - 1);
        for _ in 0..n {
            let removed = self.cells[top].clone();
            self.cells.remove(top);
            self.scrollback.push(removed);
            if self.scrollback.len() > self.max_scrollback {
                self.scrollback.remove(0);
            }
            // Insert blank row at bottom of region.
            self.cells.insert(bot, vec![Cell::default(); self.cols]);
        }
    }

    /// Scroll the scroll region down by `n` lines (CSI Ps T).
    /// Top lines are blank-filled; bottom lines are discarded.
    pub fn scroll_region_down(&mut self, n: usize) {
        let top = self.scroll_top;
        let bot = self.scroll_bottom.min(self.rows - 1);
        for _ in 0..n {
            if bot < self.rows {
                self.cells.remove(bot);
            }
            self.cells.insert(top, vec![Cell::default(); self.cols]);
        }
    }

    pub fn cursor(&self) -> (usize, usize) {
        (self.cursor_row, self.cursor_col)
    }

    pub fn cell(&self, row: usize, col: usize) -> &Cell {
        &self.cells[row][col]
    }

    pub fn resize(&mut self, rows: usize, cols: usize) {
        self.rows = rows;
        self.cols = cols;
        self.cells.resize(rows, vec![Cell::default(); cols]);
        for row in &mut self.cells {
            row.resize(cols, Cell::default());
        }
        if self.cursor_row >= rows {
            self.cursor_row = rows - 1;
        }
        if self.cursor_col >= cols {
            self.cursor_col = cols - 1;
        }
        // Re-clamp scroll region to new size.
        if self.scroll_top >= rows {
            self.scroll_top = 0;
        }
        if self.scroll_bottom >= rows {
            self.scroll_bottom = rows - 1;
        }
    }

    pub fn clear(&mut self) {
        for row in &mut self.cells {
            for cell in row.iter_mut() {
                *cell = Cell::default();
            }
        }
        self.cursor_row = 0;
        self.cursor_col = 0;
    }

    pub fn dimensions(&self) -> (usize, usize) {
        (self.rows, self.cols)
    }

    pub fn scrollback_len(&self) -> usize {
        self.scrollback.len()
    }

    pub fn set_cursor(&mut self, row: usize, col: usize) {
        self.cursor_row = row.min(self.rows.saturating_sub(1));
        self.cursor_col = col.min(self.cols.saturating_sub(1));
    }

    /// DECSTBM: set scroll region.  Both values are 1-indexed; we store 0-indexed.
    /// Passes through silently on invalid ranges.
    pub fn set_scroll_region(&mut self, top: usize, bottom: usize) {
        if top < bottom && bottom < self.rows {
            self.scroll_top = top;
            self.scroll_bottom = bottom;
        }
        // Move cursor to home position after DECSTBM (per spec).
        self.cursor_row = self.scroll_top;
        self.cursor_col = 0;
    }

    pub fn scroll_top(&self) -> usize {
        self.scroll_top
    }
    pub fn scroll_bottom(&self) -> usize {
        self.scroll_bottom
    }

    pub fn set_cell_styled(
        &mut self,
        row: usize,
        col: usize,
        ch: char,
        fg: Color,
        bg: Color,
        bold: bool,
        italic: bool,
        underline: bool,
    ) {
        if row < self.rows && col < self.cols {
            self.cells[row][col] = Cell {
                ch,
                fg,
                bg,
                bold,
                italic,
                underline,
                wide_continuation: false,
                combining: Vec::new(),
            };
        }
    }

    pub fn clear_below(&mut self) {
        for col in self.cursor_col..self.cols {
            self.cells[self.cursor_row][col] = Cell::default();
        }
        for row in (self.cursor_row + 1)..self.rows {
            for col in 0..self.cols {
                self.cells[row][col] = Cell::default();
            }
        }
    }

    pub fn clear_above(&mut self) {
        for col in 0..=self.cursor_col.min(self.cols - 1) {
            self.cells[self.cursor_row][col] = Cell::default();
        }
        for row in 0..self.cursor_row {
            for col in 0..self.cols {
                self.cells[row][col] = Cell::default();
            }
        }
    }

    pub fn clear_line(&mut self) {
        for col in 0..self.cols {
            self.cells[self.cursor_row][col] = Cell::default();
        }
    }

    pub fn clear_line_right(&mut self) {
        for col in self.cursor_col..self.cols {
            self.cells[self.cursor_row][col] = Cell::default();
        }
    }

    pub fn clear_line_left(&mut self) {
        for col in 0..=self.cursor_col.min(self.cols - 1) {
            self.cells[self.cursor_row][col] = Cell::default();
        }
    }
}