pub struct Registers([u8; 8]);

impl Registers {
    pub fn new() -> Self {
        Registers([0; 8])
    }

    pub fn set_zf(&mut self, state: bool) {
        match state {
            true => self.0[R8::F.i()] |= 0b_1000_0000,
            false => self.0[R8::F.i()] &= 0b_0111_1111,
        }
    }

    pub fn set_nf(&mut self, state: bool) {
        match state {
            true => self.0[R8::F.i()] |= 0b_0100_0000,
            false => self.0[R8::F.i()] &= 0b_1011_1111,
        }
    }

    pub fn set_hf(&mut self, state: bool) {
        match state {
            true => self.0[R8::F.i()] |= 0b_0010_0000,
            false => self.0[R8::F.i()] &= 0b_1101_1111,
        }
    }

    pub fn set_cf(&mut self, state: bool) {
        match state {
            true => self.0[R8::F.i()] |= 0b_0001_0000,
            false => self.0[R8::F.i()] &= 0b_1110_1111,
        }
    }

    pub fn set_u8(&mut self, reg: R8, val: u8) {
        self.0[reg.i()] = val;
    }

    pub fn set_u16(&mut self, reg: R16, val: u16) {
        let [ub, lb] = val.to_be_bytes();
        let (r1, r2) = reg.i();
        self.0[r1] = ub;
        self.0[r2] = lb;
    }

    pub fn get_u8(&self, reg: R8) -> u8 {
        self.0[reg.i()]
    }

    pub fn get_u16(&self, reg: R16) -> u16 {
        let (r1, r2) = reg.i();
        ((self.0[r1] as u16) << 8) | self.0[r2] as u16
    }
}

#[derive(Clone, Copy, PartialEq, Eq)]
pub enum R8 {
    A,
    F,
    B,
    C,
    D,
    E,
    H,
    L,
}

impl R8 {
    fn i(self) -> usize {
        self as usize
    }
}

#[derive(Clone, Copy, PartialEq, Eq)]
pub enum R16 {
    AF,
    BC,
    DE,
    HL,
}

impl R16 {
    pub fn i(self) -> (usize, usize) {
        match self {
            R16::AF => (R8::A.i(), R8::F.i()),
            R16::BC => (R8::B.i(), R8::C.i()),
            R16::DE => (R8::D.i(), R8::E.i()),
            R16::HL => (R8::H.i(), R8::L.i()),
        }
    }
}