use crate::vm::{error::*, reg::*};
use byteorder::{ReadBytesExt, LE};
use std::{
    io::Cursor,
    ops::{Deref, DerefMut},
};

const R1_MASK: u16 = 0b1111_1100_0000_0000;
const R2_MASK: u16 = 0b0000_0011_1111_0000;

#[derive(Debug, Clone)]
pub struct MemCursor<'mem> {
    cursor: Cursor<&'mem [u8]>,
}

impl<'mem> MemCursor<'mem> {
    pub fn new(mem: &'mem [u8]) -> Self {
        MemCursor {
            cursor: Cursor::new(mem),
        }
    }

    pub fn cursor(&self) -> &Cursor<&'mem [u8]> {
        &self.cursor
    }

    pub fn cursor_mut(&mut self) -> &mut Cursor<&'mem [u8]> {
        &mut self.cursor
    }

    pub fn next_u8(&mut self) -> Result<u8> {
        self.read_u8().map_err(|_| VmError::MemOutOfBounds {
            addr: self.position(),
        })
    }

    pub fn next_u16(&mut self) -> Result<u16> {
        self.read_u16::<LE>().map_err(|_| VmError::MemOutOfBounds {
            addr: self.position(),
        })
    }

    pub fn next_u32(&mut self) -> Result<u32> {
        self.read_u32::<LE>().map_err(|_| VmError::MemOutOfBounds {
            addr: self.position(),
        })
    }

    pub fn next_u64(&mut self) -> Result<u64> {
        self.read_u64::<LE>().map_err(|_| VmError::MemOutOfBounds {
            addr: self.position(),
        })
    }

    pub fn next_regs(&mut self) -> Result<(Reg, Reg)> {
        let next16 = self.next_u16()?;
        let r1 = ((R1_MASK & next16) >> 10) as Reg;
        let r2 = ((R2_MASK & next16) >> 4) as Reg;
        Ok((r1, r2))
    }

    pub fn next_reg(&mut self) -> Result<Reg> {
        let next16 = self.next_u16()?;
        let r1 = ((R1_MASK & next16) >> 10) as Reg;
        Ok(r1)
    }
}

impl<'mem> Deref for MemCursor<'mem> {
    type Target = Cursor<&'mem [u8]>;

    fn deref(&self) -> &Self::Target {
        self.cursor()
    }
}

impl<'mem> DerefMut for MemCursor<'mem> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.cursor_mut()
    }
}