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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
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
        }
    }

    /// Converts self into a Layout.
    pub fn into_layout(self) -> Result<Layout, LayoutError> {
        Layout::from_size_align(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 From<u128> for DynTypeId {
    fn from(val: u128) -> Self {
        DynTypeId::Unknown(val)
    }
}

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

/* 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>())
    }

    pub fn is<T: 'static>(&self) -> bool {
        match self {
            DynTypeId::Rust(tyid) => *tyid == TypeId::of::<T>(),
            DynTypeId::Unknown(_) => false,
        }
    }

    pub fn is_id<I: Into<DynTypeId>>(&self, id: I) -> bool {
        let id = id.into();
        *self == id
    }

        /// Force self into a rust TypeId, will panic if this type is not a Rust type.
    pub fn as_rust(&self) -> TypeId {
        match self {
            DynTypeId::Rust(t) => *t,
            DynTypeId::Unknown(_) => panic!("This type is unknown to rust, cannot construct a TypeId from it!"),
        }
    }
}

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

impl ComponentInfo {
    pub fn new<T: 'static>() -> Self {
        Self {
            type_id: TypeId::of::<T>().into(),
            //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>,
    {
        let _ = name; // would be used at some point
        Self {
            type_id: type_id.into(),
            //name: name.to_string(),
            layout,
        }
    }
}