use crate::vm::dm_type::DmType;
use crate::vm::object_type::DmImplementation;
use std::alloc::{alloc, dealloc, Layout};
use std::ptr;
use std::rc::Rc;

#[derive(Debug, PartialEq, Eq)]
pub struct DvmObject {
    data: Vec<*mut u8>,
    implementation: Rc<DmImplementation>,
}

fn layout_for(dm_type: &DmType) -> Layout {
    match dm_type {
        DmType::Byte => Layout::new::<u8>(),
        DmType::Int => Layout::new::<i32>(),
        DmType::Long => Layout::new::<i64>(),
        DmType::USize => Layout::new::<usize>(),
        DmType::Double => Layout::new::<f64>(),
        DmType::Boolean => Layout::new::<bool>(),
        DmType::Object => Layout::new::<Rc<DvmObject>>(),
    }
}

impl DvmObject {
    pub fn new(implementation: Rc<DmImplementation>) -> Self {
        let mut data = vec![ptr::null_mut(); implementation.fields.len()];
        for (index, field) in implementation.fields.iter().enumerate() {
            data[index] = unsafe { alloc(layout_for(field.dm_type())) }
        }
        DvmObject {
            data,
            implementation,
        }
    }

    pub fn data(&self) -> &[*mut u8] {
        &self.data
    }

    pub fn implementation(&self) -> &DmImplementation {
        &self.implementation
    }
}

impl Drop for DvmObject {
    fn drop(&mut self) {
        for (index, field) in self.implementation.fields.iter().enumerate() {
            unsafe { dealloc(self.data[index], layout_for(field.dm_type())) }
        }
    }
}