pub struct Memory {
    pub mem: [u8; 65536],
    pub pc: u16,
}

impl Memory {
    pub fn new() -> Self {
        Self {
            mem: [0; 65536],
            pc: 0,
        }
    }

    pub fn load_program(&mut self, bytecode: &[u8]) {
        self.mem[..bytecode.len()].copy_from_slice(bytecode)
    }

    pub fn read_u8(&self, addr: u16) -> u8 {
        self.mem[addr as usize]
    }

    pub fn write_u8(&mut self, val: u8, addr: u16) {
        self.mem[addr as usize] = val;
    }

    pub fn read_u8_next(&mut self) -> u8 {
        let byte = self.mem[self.pc as usize];
        self.pc = self.pc.wrapping_add(1);
        byte
    }

    pub fn read_u16(&self, addr: u16) -> u16 {
        let byte_high = self.read_u8(addr);
        let byte_low = self.read_u8(addr.wrapping_add(1));
        u16::from_be_bytes([byte_high, byte_low])
    }

    pub fn write_u16(&mut self, val: u16, addr: u16) {
        let [byte_high, byte_low] = val.to_be_bytes();
        self.write_u8(byte_high, addr);
        self.write_u8(byte_low, addr.wrapping_add(1));
    }

    pub fn read_u16_next(&mut self) -> u16 {
        let byte_high = self.read_u8_next();
        let byte_low = self.read_u8_next();
        u16::from_be_bytes([byte_high, byte_low])
    }

    pub fn read_pc(&self) -> u16 {
        self.pc
    }

    pub fn write_pc(&mut self, val: u16) {
        self.pc = val;
    }

    pub fn reset(&mut self) {
        self.mem.fill(0);
        self.pc = 0;
    }
}