use std::{any::{TypeId, type_name}, alloc::{Layout, LayoutError}};

#[derive(Clone, Copy, Debug)]
pub struct MemoryLayout {
    pub size: usize,
    pub alignment: usize
}

impl TryInto<Layout> for MemoryLayout {
    type Error = LayoutError;

    fn try_into(self) -> Result<Layout, Self::Error> {
        Layout::from_size_align(self.size, self.alignment)
    }
}

impl From<Layout> for MemoryLayout {
    fn from(value: Layout) -> Self {
        Self {
            size: value.size(),
            alignment: value.align(),
        }
    }
}

impl MemoryLayout {
    pub fn new(size: usize, alignment: usize) -> Self {
        MemoryLayout {
            size,
            alignment
        }
    }

    pub unsafe fn into_layout_unchecked(self) -> Layout {
        Layout::from_size_align_unchecked(self.size, self.alignment)
    }
}

/// A dynamic type id. Supports types that are not known to Rust.
#[derive(Clone, Copy, Hash, Debug, PartialEq, Eq)]
pub enum DynTypeId {
    Rust(TypeId),
    Unknown(u128),
}

impl Into<DynTypeId> for u128 {
    fn into(self) -> DynTypeId {
        DynTypeId::Unknown(self)
    }
}

impl From<TypeId> for DynTypeId {
    fn from(value: TypeId) -> Self {
        DynTypeId::Rust(value)
    }
}

impl DynTypeId {
    pub fn of<T: 'static>() -> Self {
        Self::Rust(TypeId::of::<T>())
    }
}

#[derive(Clone, Debug)]
pub struct ComponentInfo {
    pub type_id: DynTypeId,
    pub name: String,
    pub layout: MemoryLayout,
}

impl ComponentInfo {
    pub fn new<T: 'static>() -> Self {
        Self {
            type_id: DynTypeId::from(TypeId::of::<T>()),
            name: type_name::<T>().to_string(),
            layout: MemoryLayout::from(Layout::new::<T>()),
        }
    }

    /// Create ComponentInfo from a type that is not known to rust
    pub fn new_unknown<D>(type_id: D, name: &str, layout: MemoryLayout) -> Self
    where
        D: Into<DynTypeId>,
    {
        Self {
            type_id: type_id.into(),
            name: name.to_string(),
            layout,
        }
    }
}