use std::any::{type_name, Any};
use std::convert::Infallible;
use std::fmt::Debug;
use std::marker::PhantomData;
use std::ops::{Deref, DerefMut};
use std::panic::{RefUnwindSafe, UnwindSafe};
use std::ptr::addr_of;

use seq_macro::seq;

use crate::component::{Component, FromOptionalComponent};
use crate::lock::WriteGuard;
use crate::system::util::check_params_are_compatible;
use crate::tuple::{ReduceElement as TupleReduceElement, With as TupleWith};
use crate::WorldData;

pub mod stateful;

mod util;

pub trait System<'world, Impl>: 'static
{
    type Input;

    #[must_use]
    fn initialize(self, input: Self::Input) -> Self;

    fn run<'this>(&'this self, world_data: &'world WorldData)
    where
        'this: 'world;

    fn into_type_erased(self) -> TypeErased;

    fn get_local_component_mut<LocalComponent: Component>(
        &self,
    ) -> Option<ComponentRefMut<LocalComponent>>;

    fn set_local_component<LocalComponent: Component>(
        &mut self,
        local_component: LocalComponent,
    );
}

macro_rules! impl_system {
    ($c: tt) => {
        seq!(I in 0..$c {
            impl<'world, Func, #(TParam~I,)*> System<'world, fn(#(TParam~I,)*)>
                for Func
            where
                Func: Fn(#(TParam~I,)*) + Copy + RefUnwindSafe + UnwindSafe + 'static,
                #(TParam~I: Param<'world, Flags = NoInitParamFlag>,)*
            {
                type Input = Infallible;

                fn initialize(self, _input: Self::Input) -> Self
                {
                    self
                }

                fn run<'this>(&'this self, world_data: &'world WorldData)
                where
                    'this: 'world
                {
                    #(
                        check_params_are_compatible!(I, TParam~I, $c);
                    )*

                    let func = *self;

                    func(#({
                        TParam~I::new(self, world_data)
                    },)*);
                }

                fn into_type_erased(self) -> TypeErased
                {
                    TypeErased {
                        data: Box::new(self),
                        func: Box::new(|data, world_data| {
                            // SAFETY: The caller of TypeErased::run ensures the lifetime
                            // is correct
                            let data = unsafe { &*addr_of!(*data) };

                            let me = data
                                .downcast_ref::<Func>()
                                .expect("Function downcast failed");

                            // SAFETY: The caller of TypeErased::run ensures the lifetime
                            // is correct
                            let world_data = unsafe {
                                &*(world_data as *const WorldData)
                            };

                            me.run(world_data);
                        }),
                    }
                }

                fn get_local_component_mut<LocalComponent: Component>(
                    &self,
                ) -> Option<ComponentRefMut<LocalComponent>>
                {
                    panic!("System does not have any local components");
                }

                fn set_local_component<LocalComponent: Component>(
                    &mut self,
                    _local_component: LocalComponent,
                ) {
                    panic!("System does not have any local components");
                }
            }
        });
    };
}

seq!(C in 1..16 {
    impl_system!(C);
});

pub trait Into<Impl>
{
    type System;

    fn into_system(self) -> Self::System;
}

pub struct TypeErased
{
    data: Box<dyn Any + RefUnwindSafe + UnwindSafe>,
    func: Box<TypeErasedFunc>,
}

impl TypeErased
{
    /// Runs the system.
    ///
    /// # Safety
    /// `world_data` must live at least as long as the [`World`] the system belongs to.
    pub unsafe fn run(&self, world_data: &WorldData)
    {
        // You have to dereference for downcasting to work for some reason
        let data = &*self.data;

        (self.func)(data, world_data);
    }
}

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

/// Function in [`TypeErased`] used to run the system.
type TypeErasedFunc = dyn Fn(&dyn Any, &WorldData) + RefUnwindSafe + UnwindSafe;

/// A parameter to a [`System`].
///
/// # Safety
/// The `is_compatible` function is used for safety so it must be implemented properly.
pub unsafe trait Param<'world>
{
    type Input;
    type Flags;

    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;

    fn is_compatible<Other: Param<'world>>() -> bool;

    fn get_comparable() -> Box<dyn Any>;
}

pub struct NoInitParamFlag {}

/// A type which can be used as input to a [`System`].
pub trait Input: 'static {}

/// Component tuple reducing operation to get the parameters that takes input.
pub struct ParamWithInputFilter;

impl<InputT: Input, Accumulator> TupleReduceElement<Accumulator, ParamWithInputFilter>
    for InputT
where
    Accumulator: TupleWith<Self>,
{
    type Return = Accumulator::With;
}

impl<Accumulator> TupleReduceElement<Accumulator, ParamWithInputFilter> for ()
{
    type Return = Accumulator;
}

#[derive(Debug)]
pub struct ComponentRefMut<'a, ComponentT: Component>
{
    inner: WriteGuard<'a, Box<dyn Component>>,
    _ph: PhantomData<ComponentT>,
}

impl<'a, ComponentT: Component> ComponentRefMut<'a, ComponentT>
{
    pub(crate) fn new(inner: WriteGuard<'a, Box<dyn Component>>) -> Self
    {
        Self { inner, _ph: PhantomData }
    }
}

impl<'component, ComponentT: Component> FromOptionalComponent<'component>
    for ComponentRefMut<'component, ComponentT>
{
    fn from_optional_component(
        inner: Option<WriteGuard<'component, Box<dyn Component>>>,
    ) -> Self
    {
        Self {
            inner: inner.unwrap_or_else(|| {
                panic!(
                    "Component {} was not found in entity",
                    type_name::<ComponentT>()
                );
            }),
            _ph: PhantomData,
        }
    }
}

impl<'comp, ComponentT> FromOptionalComponent<'comp>
    for Option<ComponentRefMut<'comp, ComponentT>>
where
    ComponentT: Component,
{
    fn from_optional_component(
        optional_component: Option<WriteGuard<'comp, Box<dyn Component>>>,
    ) -> Self
    {
        optional_component.map(|component| ComponentRefMut::new(component))
    }
}

impl<'a, ComponentT: Component> Deref for ComponentRefMut<'a, ComponentT>
{
    type Target = ComponentT;

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

impl<'a, ComponentT: Component> DerefMut for ComponentRefMut<'a, ComponentT>
{
    fn deref_mut(&mut self) -> &mut Self::Target
    {
        self.inner.downcast_mut().unwrap()
    }
}