/*!
 * Different component traits usually implmented using the corresponding derive attribute.
 */

use crate::storage::{Storage, OneToNStorage, OneToNForest};

// #[cfg(not(feature="dynamic_systems"))]
use std::any::TypeId;
use std::ops::Deref;
use std::borrow::Borrow;
use crate::Entity;

pub type Id = TypeId;

/// Main Component trait.
///
/// Usually implemented using a derive attribute as in:
///
/// ```
/// # #[macro_use] extern crate rinecs_derive;
/// #[derive(Component, Debug)]
/// struct Position{}
/// ```
///
/// Allows to add a type as an entity's component.
pub trait Component: 'static + Sized {
    type Storage;
    type MutStorageCacheGuard: crate::sync::CacheConstructor;

    fn type_name() -> &'static str;

    #[inline]
    fn id() -> Id {
        TypeId::of::<Self>()
    }

    fn is_reference() -> bool;
    fn references_other() -> Option<Box<dyn Fn(&crate::storage::Storages, &Entity) -> Entity>>{
        None
    }
}

/// `Send` `Component`.
///
/// Shouldn't be used directly, is automatically implemented
/// by any component that is also `Send`.
pub trait ComponentSend: Component + Send{}
impl<C: Component + Send> ComponentSend for C{}

/// Non `Send` `Component`.
///
/// Shouldn't be used directly, is automatically implemented
/// by any component that is not `Send`.
pub trait ComponentThreadLocal: Component{}
impl<C: Component> ComponentThreadLocal for C{}


/// One to N Component trait.
///
/// Usually implemented using a derive attribute as in:
///
/// ```
/// # #[macro_use] extern crate rinecs_derive;
/// #[derive(OneToNComponent, Debug)]
/// struct Geometry{}
/// ```
///
/// Allows to add a slice of this type as an entity's component.
pub trait OneToNComponent: 'static + Sized
    where Self: Component,
          for<'a> <Self as Component>::Storage: OneToNStorage<'a, Self>
{
    fn slice_type_name() -> &'static str;
}

/// `Send` `OneToNComponent`.
///
/// Shouldn't be used directly, is automatically implemented
/// by any one to n component that is also `Send`.
pub trait OneToNComponentSend: OneToNComponent + Send
    where for<'a> <Self as Component>::Storage: OneToNStorage<'a, Self>{}
impl<C: OneToNComponent + Send> OneToNComponentSend for C
    where for<'a> <C as Component>::Storage: OneToNStorage<'a, Self>{}

/// Non `Send` `OneToNComponent`.
///
/// Shouldn't be used directly, is automatically implemented
/// by any one to n component that is not `Send`.
pub trait OneToNComponentThreadLocal: OneToNComponent
    where for<'a> <Self as Component>::Storage: OneToNStorage<'a, Self>{}
impl<C: OneToNComponent> OneToNComponentThreadLocal for C
    where for<'a> <C as Component>::Storage: OneToNStorage<'a, Self>{}



// Hierarchical OneToN
#[doc(hidden)]
pub trait HierarchicalOneToNComponent: 'static + Sized + Component<Storage = OneToNForest<Self>>{}

#[doc(hidden)]
pub trait HierarchicalOneToNComponentSend: HierarchicalOneToNComponent + Send{}
impl<'a, C: HierarchicalOneToNComponent + Send> HierarchicalOneToNComponentSend for C{}

#[doc(hidden)]
pub trait HierarchicalOneToNComponentThreadLocal: HierarchicalOneToNComponent{}
impl<'a, C: HierarchicalOneToNComponent> HierarchicalOneToNComponentThreadLocal for C{}

pub trait ReferenceType{
    type ReferenceType;
}


/// N to One components are just references to other entities.
///
/// That way several entities can have the same components in common.
///
/// ```
/// # #[macro_use] extern crate rinecs_derive;
/// # use rinecs::*;
/// #[derive(NToOneComponent, Debug)]
/// struct ComponentRef(Entity);
/// ```
///
/// Automatically implements NToOneComponent and can be used with ReadRef and Ref.
pub trait NToOneComponent<'a>: 'static + Sized + Component + Deref<Target = Entity>{
    // fn references_other() -> Box<dyn Fn(&crate::storage::Storages, &Entity) -> Entity>;
}
/// `Send` N to One `Component`
pub trait NToOneComponentSend<'a>: NToOneComponent<'a> + Send{}
impl<'a, C> NToOneComponentSend<'a> for C
where
    C: 'static + Sized + NToOneComponent<'a> + Send + Deref<Target = Entity>,
    <C as Component>::Storage: Storage<'a, C>,
    <<C as Component>::Storage as Storage<'a, C>>::Get: Borrow<<<C as Component>::Storage as Storage<'a, C>>::DerefTarget>,
    <<C as Component>::Storage as Storage<'a, C>>::DerefTarget: Deref<Target = Entity>{}

/// Non `Send` N to One `Component`
pub trait NToOneComponentThreadLocal<'a>: NToOneComponent<'a>{}
impl<'a, C> NToOneComponentThreadLocal<'a> for C
where
    C: 'static + Sized + NToOneComponent<'a> + Deref<Target = Entity>,
    <C as Component>::Storage: Storage<'a, C>,
    <<C as Component>::Storage as Storage<'a, C>>::Get: Borrow<<<C as Component>::Storage as Storage<'a, C>>::DerefTarget>,
    <<C as Component>::Storage as Storage<'a, C>>::DerefTarget: Deref<Target = Entity>{}


/// One to One components are just references to other entities where the reference must be unique.
///
/// It allows to have more than one component of the same type by using a reference.
///
/// Attempting to insert a non unique component will panic.
///
/// ```
/// # #[macro_use] extern crate rinecs_derive;
/// # use rinecs::*;
/// #[derive(OneToOneComponent, Debug, Hash)]
/// struct ComponentRef(Entity);
/// ```
///
/// Automatically implements OneToOneComponent and can be used with ReadRef and Ref.
pub trait OneToOneComponent<'a>: 'static + Sized + Component + Deref<Target = Entity>{
    // fn references_other() -> Box<dyn Fn(&crate::storage::Storages, &Entity) -> Entity>;
}
/// `Send` N to One `Component`
pub trait OneToOneComponentSend<'a>: OneToOneComponent<'a> + Send{}
impl<'a, C> OneToOneComponentSend<'a> for C
where
    C: 'static + Sized + OneToOneComponent<'a> + Send + Deref<Target = Entity>,
    <C as Component>::Storage: Storage<'a, C>,
    <<C as Component>::Storage as Storage<'a, C>>::Get: Borrow<<<C as Component>::Storage as Storage<'a, C>>::DerefTarget>,
    <<C as Component>::Storage as Storage<'a, C>>::DerefTarget: Deref<Target = Entity>{}

/// Non `Send` N to One `Component`
pub trait OneToOneComponentThreadLocal<'a>: OneToOneComponent<'a>{}
impl<'a, C> OneToOneComponentThreadLocal<'a> for C
where
    C: 'static + Sized + OneToOneComponent<'a> + Deref<Target = Entity>,
    <C as Component>::Storage: Storage<'a, C>,
    <<C as Component>::Storage as Storage<'a, C>>::Get: Borrow<<<C as Component>::Storage as Storage<'a, C>>::DerefTarget>,
    <<C as Component>::Storage as Storage<'a, C>>::DerefTarget: Deref<Target = Entity>{}

pub trait HasChanged{
    fn changed(&self) -> bool;
}

pub trait Changes{
    fn has_changed(&self) -> bool;
    fn reset_changed(&mut self);
}

impl<'a, T: Changes> Changes for &'a mut T{
    fn has_changed(&self) -> bool {
        (**self).has_changed()
    }

    fn reset_changed(&mut self) {
        (**self).reset_changed()
    }
}

impl<'a, T: Changes> HasChanged for &'a T{
    fn changed(&self) -> bool {
        (**self).has_changed()
    }
}