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

use crate::uid::Uid;
use crate::component::HandleMut as ComponentHandleMut;
use crate::component::IntoParts as IntoComponentParts;
use crate::system::{Metadata as SystemMetadata, Param as SystemParam};
use crate::World;

/// A type which has a single instance and is shared globally.
pub trait Sole: Any + IntoComponentParts
{
    fn id() -> Uid
    where
        Self: Sized;

    fn type_reflection() -> Option<&'static crate::reflection::Type>
    where
        Self: Sized;

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

impl dyn Sole
{
    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 Sole
{
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
    {
        formatter.debug_struct("Sole").finish_non_exhaustive()
    }
}

/// Holds a reference to a globally shared singleton value.
#[derive(Debug)]
pub struct Single<'world, SoleT: Sole>
{
    sole: ComponentHandleMut<'world, SoleT>,
}


impl<'world, SoleT> Single<'world, SoleT>
where
    SoleT: Sole,
{
    pub(crate) fn new(sole: ComponentHandleMut<'world, SoleT>) -> Self
    {
        Self { sole }
    }
}

impl<'world, SoleT> SystemParam<'world> for Single<'world, SoleT>
where
    SoleT: Sole,
{
    type Input = ();

    fn new(world: &'world World, _system_metadata: &SystemMetadata) -> Self
    {
        let sole = world
            .get_entity(SoleT::id())
            .and_then(|ent| ent.get_with_id_mut::<SoleT>(SoleT::id()))
            .unwrap_or_else(|| {
                panic!("Sole component {} was not found in world", type_name::<SoleT>())
            });

        Self::new(sole)
    }
}

impl<SoleT> Deref for Single<'_, SoleT>
where
    SoleT: Sole,
{
    type Target = SoleT;

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

impl<SoleT> DerefMut for Single<'_, SoleT>
where
    SoleT: Sole,
{
    fn deref_mut(&mut self) -> &mut Self::Target
    {
        &mut *self.sole
    }
}