pub trait EncryptedReaderWriter {
    fn write_u8(&mut self, address: usize, value: u8) {
        let bytes = [value];
        self.write_bytes(address, &bytes);
    }

    fn write_u16(&mut self, address: usize, value: u16) {
        let bytes = value.to_le_bytes();
        self.write_bytes(address, &bytes);
    }

    fn write_u32(&mut self, address: usize, value: u32) {
        let bytes = value.to_le_bytes();
        self.write_bytes(address, &bytes);
    }

    fn write_u64(&mut self, address: usize, value: u64) {
        let bytes = value.to_le_bytes();
        self.write_bytes(address, &bytes);
    }

    fn read_u8(&self, address: usize) -> u8 {
        self.read_bytes(address, 1)[0]
    }

    fn read_u16(&self, address: usize) -> u16 {
        let bytes = self.read_bytes(address, 2);
        u16::from_le_bytes([bytes[0], bytes[1]])
    }

    fn read_u32(&self, address: usize) -> u32 {
        let bytes = self.read_bytes(address, 4);
        u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
    }

    fn read_u64(&self, address: usize) -> u64 {
        let bytes = self.read_bytes(address, 8);
        u64::from_le_bytes([
            bytes[0],
            bytes[1],
            bytes[2],
            bytes[3],
            bytes[4],
            bytes[5],
            bytes[6],
            bytes[7],
        ])
    }

    /// Reads bytes from the specified section/stack address and length, returning a Value.
    ///
    /// # Arguments
    ///
    /// * `address` - The address to read from.
    /// * `length` - The number of bites to read (must be 8, 16, 32, or 64).
    ///
    /// # Returns
    /// A `Value` containing the read data.
    fn read_bytes_as_value(&self, address: usize, length: usize) -> Value {
        match length {
            8 => Value::new_u8(self.read_u8(address)),
            16 => Value::new_u16(self.read_u16(address)),
            32 => Value::new_u32(self.read_u32(address)),
            64 => Value::new_u64(self.read_u64(address)),
            // the only case where size "should" be 0 is for memory operands in LEA instruction.
            // Those operands are not supposed to actually be accessed, only the effective address is supposed to be calculated
            // Thus their size is 0.
            // Here, we treat it as a 64 bit value for debugging purpose.
            _ => Value::new_u64(self.read_u64(address)),
        }
    }

    /// Reads bytes from the specified section/stack address and size, returning a Value.
    ///
    /// # Arguments
    ///
    /// * `address` - The address to read from.
    /// * `size` - The number of bites to read (must be 8, 16, 32, or 64).
    ///
    /// # Returns
    /// A `Value` containing the read data.
    fn read_encrypted_bytes_as_value(&mut self, address: u64, size: u8) -> Value {
        self.decrypt();
        let unencrypted_value = self.read_bytes_as_value(address as usize, size as usize);
        self.encrypt();
        unencrypted_value
    }

    fn write_encrypted_value(&mut self, address: u64, value: Value, size: u8) {
        self.decrypt();
        match size {
            8 => self.write_u8(address as usize, unsafe { value.u8 }),
            16 => self.write_u16(address as usize, unsafe { value.u16 }),
            32 => self.write_u32(address as usize, unsafe { value.u32 }),
            64 => self.write_u64(address as usize, unsafe { value.u64 }),
            _ => self.write_u64(address as usize, unsafe { value.u64 }),
        }
        self.encrypt();
    }

    fn with_decryption<F, R>(&mut self, f: F) -> R where F: FnOnce(&mut Self) -> R {
        self.decrypt();
        let result = f(self);
        self.encrypt();
        result
    }

    fn decrypt(&mut self);

    fn encrypt(&mut self);

    fn write_bytes(&mut self, address: usize, data: &[u8]);

    fn read_bytes(&self, address: usize, length: usize) -> Vec<u8>;
}