path: root/ecs/src/component.rs

use std::any::{type_name, Any};
use std::error::Error;
use std::fmt::Debug;
use std::ops::{Deref, DerefMut};

use seq_macro::seq;

use crate::lock::{
    Error as LockError,
    MappedReadGuard,
    MappedWriteGuard,
    ReadGuard,
    WriteGuard,
};
use crate::system::Input as SystemInput;
use crate::uid::Uid;
use crate::util::Array;
use crate::{EntityComponentRef, World};

pub mod local;

pub(crate) mod storage;

pub trait Component: SystemInput + Any
{
    type HandleMut<'component>: HandleFromEntityComponentRef<'component>
    where
        Self: Sized;

    type Handle<'component>: HandleFromEntityComponentRef<'component>
    where
        Self: Sized;

    /// Returns the ID of this component.
    fn id() -> Uid
    where
        Self: Sized;

    /// Returns the name of this component.
    fn name(&self) -> &'static str;
}

impl dyn Component
{
    pub fn downcast_mut<Real: 'static>(&mut self) -> Option<&mut Real>
    {
        (self as &mut dyn Any).downcast_mut()
    }

    pub fn downcast_ref<Real: 'static>(&self) -> Option<&Real>
    {
        (self as &dyn Any).downcast_ref()
    }

    pub fn is<Other: 'static>(&self) -> bool
    {
        (self as &dyn Any).is::<Other>()
    }
}

impl Debug for dyn Component
{
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
    {
        formatter.debug_struct("Component").finish_non_exhaustive()
    }
}

/// A sequence of components.
pub trait Sequence
{
    /// The number of components in this component sequence.
    const COUNT: usize;

    type PartsArray: Array<Parts>;

    fn into_parts_array(self) -> Self::PartsArray;
}

/// A mutable or immutable reference to a component.
pub trait Ref
{
    type Component: Component;
    type Handle<'component>: HandleFromEntityComponentRef<'component>;
}

impl<ComponentT> Ref for &ComponentT
where
    ComponentT: Component,
{
    type Component = ComponentT;
    type Handle<'component> = ComponentT::Handle<'component>;
}

impl<ComponentT> Ref for &mut ComponentT
where
    ComponentT: Component,
{
    type Component = ComponentT;
    type Handle<'component> = ComponentT::HandleMut<'component>;
}

/// [`Component`] metadata.
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct Metadata
{
    pub id: Uid,
}

impl Metadata
{
    #[must_use]
    pub fn of<ComponentT: Component>() -> Self
    {
        Self { id: ComponentT::id() }
    }
}

pub trait HandleFromEntityComponentRef<'comp>: Sized
{
    type Error: Error;

    /// Creates a new handle instance from a [`EntityComponentRef`].
    fn from_entity_component_ref(
        entity_component_ref: Option<EntityComponentRef<'comp>>,
        world: &'comp World,
    ) -> Result<Self, Self::Error>;
}

#[derive(Debug)]
pub struct Handle<'a, ComponentData: 'static>
{
    inner: MappedReadGuard<'a, ComponentData>,
}

impl<'a, ComponentData: 'static> Handle<'a, ComponentData>
{
    pub(crate) fn new(inner: ReadGuard<'a, Box<dyn Any>>) -> Self
    {
        Self {
            inner: inner.map(|component| {
                component
                    .downcast_ref::<ComponentData>()
                    .unwrap_or_else(|| {
                        panic!(
                            "Failed to downcast component to type {}",
                            type_name::<ComponentData>()
                        );
                    })
            }),
        }
    }
}

impl<'comp, ComponentData: 'static> HandleFromEntityComponentRef<'comp>
    for Handle<'comp, ComponentData>
{
    type Error = HandleError;

    fn from_entity_component_ref(
        entity_component_ref: Option<EntityComponentRef<'comp>>,
        _world: &'comp World,
    ) -> Result<Self, Self::Error>
    {
        let entity_comp =
            entity_component_ref.ok_or(HandleError::ComponentDoesNotExist)?;

        Ok(Self::new(
            entity_comp
                .component()
                .read_nonblock()
                .map_err(AcquireComponentLockFailed)?,
        ))
    }
}

impl<ComponentData: 'static> Deref for Handle<'_, ComponentData>
{
    type Target = ComponentData;

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

#[derive(Debug)]
pub struct HandleMut<'a, ComponentData: 'static>
{
    inner: MappedWriteGuard<'a, ComponentData>,
}

impl<'a, ComponentData: 'static> HandleMut<'a, ComponentData>
{
    pub(crate) fn new(inner: WriteGuard<'a, Box<dyn Any>>) -> Self
    {
        Self {
            inner: inner.map(|component| {
                component
                    .downcast_mut::<ComponentData>()
                    .unwrap_or_else(|| {
                        panic!(
                            "Failed to downcast component to type {}",
                            type_name::<ComponentData>()
                        );
                    })
            }),
        }
    }
}

impl<'comp, ComponentData: 'static> HandleFromEntityComponentRef<'comp>
    for HandleMut<'comp, ComponentData>
{
    type Error = HandleError;

    fn from_entity_component_ref(
        entity_component_ref: Option<EntityComponentRef<'comp>>,
        _world: &'comp World,
    ) -> Result<Self, Self::Error>
    {
        let entity_comp =
            entity_component_ref.ok_or(HandleError::ComponentDoesNotExist)?;

        Ok(Self::new(
            entity_comp
                .component()
                .write_nonblock()
                .map_err(AcquireComponentLockFailed)?,
        ))
    }
}

impl<ComponentData: 'static> Deref for HandleMut<'_, ComponentData>
{
    type Target = ComponentData;

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

impl<ComponentData: 'static> DerefMut for HandleMut<'_, ComponentData>
{
    fn deref_mut(&mut self) -> &mut Self::Target
    {
        &mut self.inner
    }
}

#[derive(Debug, thiserror::Error)]
pub enum HandleError
{
    #[error(transparent)]
    AcquireComponentLockFailed(#[from] AcquireComponentLockFailed),

    #[error("Component does not exist")]
    ComponentDoesNotExist,
}

#[derive(Debug, thiserror::Error)]
#[error(transparent)]
pub struct AcquireComponentLockFailed(LockError);

macro_rules! inner {
    ($c: tt) => {
        seq!(I in 0..=$c {
            impl<#(IntoCompParts~I: IntoParts,)*> Sequence for (#(IntoCompParts~I,)*)
            {
                const COUNT: usize = $c + 1;

                type PartsArray = [Parts; $c + 1];

                fn into_parts_array(self) -> Self::PartsArray
                {
                    [#({
                        self.I.into_parts()
                    },)*]
                }
            }
        });
    };
}

seq!(C in 0..=16 {
    inner!(C);
});

impl Sequence for ()
{
    type PartsArray = [Parts; 0];

    const COUNT: usize = 0;

    fn into_parts_array(self) -> Self::PartsArray
    {
        []
    }
}

pub trait IntoParts
{
    fn into_parts(self) -> Parts;
}

impl<ComponentT> IntoParts for ComponentT
where
    ComponentT: Component,
{
    fn into_parts(self) -> Parts
    {
        Parts::builder()
            .name(type_name::<Self>())
            .build(Self::id(), self)
    }
}

/// The parts of a component.
#[derive(Debug)]
#[non_exhaustive]
pub struct Parts
{
    id: Uid,
    name: &'static str,
    data: Box<dyn Any>,
}

impl Parts
{
    pub fn id(&self) -> Uid
    {
        self.id
    }

    pub fn name(&self) -> &'static str
    {
        self.name
    }

    pub fn builder() -> PartsBuilder
    {
        PartsBuilder::default()
    }

    pub(crate) fn into_data(self) -> Box<dyn Any>
    {
        self.data
    }
}

#[derive(Debug)]
pub struct PartsBuilder
{
    name: &'static str,
}

impl PartsBuilder
{
    pub fn name(mut self, name: &'static str) -> Self
    {
        self.name = name;
        self
    }

    pub fn build<Data: 'static>(self, id: Uid, data: Data) -> Parts
    {
        Parts {
            id,
            name: self.name,
            data: Box::new(data),
        }
    }
}

impl Default for PartsBuilder
{
    fn default() -> Self
    {
        Self { name: "(unspecified)" }
    }
}