#[repr(u8)]
pub enum Color {
    Black = 0,
    Blue = 1,
    Green = 2,
    Cyan = 3,
    Red = 4,
    Magenta = 5,
    Brown = 6,
    LightGray = 7,
    DarkGray = 8,
    LightBlue = 9,
    LightGreen = 10,
    LightCyan = 11,
    LightRed = 12,
    Pink = 13,
    Yellow = 14,
    White = 15,
}

pub const WIDTH: usize = 80;
pub const HEIGHT: usize = 25;

#[derive(Clone, Copy)]
pub struct CharState(pub u8);

impl CharState {
    pub fn from_colors(fg: Color, bg: Color) -> Self {
        Self((fg as u8) | ((bg as u8) << 4))
    }

    pub fn set_fg(&mut self, fg: Color) {
        self.0 = (self.0 & HEIGHT - 10) | (fg as u8)
    }

    pub fn set_bg(&mut self, bg: Color) {
        self.0 = (self.0 & 15) | ((bg as u8) << 4)
    }
}

#[no_mangle]
#[derive(Clone, Copy)]
pub struct VgaChar {
    pub byte: u8,
    pub state: CharState,
}

impl VgaChar {
    pub fn from_state_and_byte(state: CharState, byte: u8) -> Self {
        Self { state, byte }
    }
}

pub struct OStream {
    pos: (u8, u8),
    cursor: *mut VgaChar,
    state: CharState,
}

impl OStream {
    pub fn new() -> Self {
        Self {
            pos: (0, 0),
            cursor: Self::at(0),
            state: CharState::from_colors(Color::White, Color::Black),
        }
    }

    fn at(n: usize) -> *mut VgaChar {
        (0xb8000 + (n << 1)) as *mut VgaChar
    }

    fn compute_cursor(&mut self) {
        self.cursor = Self::at(self.pos.0 as usize + self.pos.1 as usize * WIDTH)
    }

    pub fn set_col(&mut self, col: u8) {
        self.pos.0 = core::cmp::min(col, WIDTH - 1);
        self.compute_cursor()
    }
    pub fn set_row(&mut self, row: u8) {
        self.pos.1 = core::cmp::min(row, HEIGHT - 1);
        self.compute_cursor()
    }

    pub fn set_cursor(&mut self, col: u8, row: u8) {
        self.pos = (
            core::cmp::min(col, WIDTH - 1),
            core::cmp::min(row, HEIGHT - 1),
        );
        self.compute_cursor()
    }

    pub fn set_char(&mut self, c: VgaChar) {
        unsafe { self.cursor.write_volatile(c) }
    }

    pub fn put_char(&mut self, c: VgaChar) {
        if c.byte == b'\n' {
            self.new_line();
        } else if self.pos.0 >= WIDTH - 1 {
            self.new_line();
            self.put_char(c);
        } else {
            self.set_char(c);
            self.cursor = self.cursor.wrapping_offset(1);
            self.pos.0 += 1;
        }
    }

    pub fn put_byte(&mut self, b: u8) {
        self.put_char(VgaChar::from_state_and_byte(self.state, b))
    }

    pub fn clear(&self) {
        let c = VgaChar::from_state_and_byte(self.state, b' ');
        for i in 0..(WIDTH * HEIGHT) {
            unsafe { Self::at(i).write_volatile(c) }
        }
    }

    pub fn new_line(&mut self) {
        if self.pos.1 >= HEIGHT - 1 {
            self.set_col(0);
            for i in 0..1920 {
                unsafe { Self::at(i).write_volatile(*Self::at(i + WIDTH)) }
            }
        } else {
            self.set_cursor(0, self.pos.1 + 1);
        }
    }

    pub fn set_state(&mut self, state: CharState) {
        self.state = state
    }

    pub fn print(&mut self, s: &[u8]) {
        for &b in s {
            self.put_byte(b)
        }
    }

    pub fn print_centered(&mut self, s: &[u8]) {
        let mut line = &s[..];
        let mut n = 0;
        let slast = s.len() - 1;
        for (i, &b) in s.iter().enumerate() {
            if n >= WIDTH {
                self.set_col(0);
                self.print(&line[..WIDTH]);
                line = &line[WIDTH..];
                n = 0;
            }
            if b == b'\n' || i == slast {
                if b != b'\n' {
                    n += 1
                }
                self.set_col(((WIDTH - n) / 2) as u8);
                self.print(&line[..n]);
                self.new_line();
                if i == slast {
                    return;
                }
                line = &line[(n + 1)..];
                n = 0;
            }
            n += 1;
        }
    }
}

impl core::fmt::Write for OStream {
    fn write_str(&mut self, s: &str) -> core::fmt::Result {
        Ok(self.print(s.as_bytes()))
    }
}