use std::any::Any;

use crate::lock::WriteGuard;
use crate::system::{
    NoInitParamFlag as NoInitSystemParamFlag,
    Param as SystemParam,
    System,
};
use crate::tuple::FilterExclude as TupleFilterExclude;
use crate::{WorldData, WorldFlags};

#[derive(Debug)]
pub struct Flags<'world>
{
    world_flags: WriteGuard<'world, WorldFlags>,
}

impl<'world> Flags<'world>
{
    /// Calling this function makes the loop in [`Engine::event_loop`] stop at the next
    /// opportune time.
    pub fn stop(&mut self)
    {
        self.world_flags.stop = true;
    }
}

unsafe impl<'world> SystemParam<'world> for Flags<'world>
{
    type Flags = NoInitSystemParamFlag;
    type Input = TupleFilterExclude;

    fn initialize<SystemImpl>(
        _system: &mut impl System<'world, SystemImpl>,
        _input: Self::Input,
    )
    {
    }

    fn new<SystemImpl>(
        _system: &'world impl System<'world, SystemImpl>,
        world_data: &'world WorldData,
    ) -> Self
    {
        Self {
            world_flags: world_data
                .flags
                .write_nonblock()
                .expect("Failed to acquire read-write world flags lock"),
        }
    }

    fn is_compatible<Other: SystemParam<'world>>() -> bool
    {
        let other_comparable = Other::get_comparable();

        other_comparable.downcast_ref::<Comparable>().is_none()
    }

    fn get_comparable() -> Box<dyn Any>
    {
        Box::new(Comparable)
    }
}

struct Comparable;