use std::any::type_name;
use std::marker::PhantomData;

use seq_macro::seq;
use paste::paste;
use util_macros::sub;

use crate::component::{
    Component,
    Handle as ComponentHandle,
    HandleMut as ComponentHandleMut,
};
use crate::entity::Handle as EntityHandle;
use crate::query::flexible::{Iter as FlexibleQueryIter, Query as FlexibleQuery};
use crate::system::{Metadata as SystemMetadata, Param as SystemParam};
use crate::tuple::Tuple;
use crate::uid::Uid;
use crate::util::array_vec::ArrayVec;
use crate::util::Array;
use crate::World;

pub mod flexible;
pub mod term;

// A term tuple type can have a maximum of 17 elements
pub const MAX_TERM_CNT: usize = 17;

#[derive(Debug)]
pub struct Query<'world, TermsT>
where
    TermsT: TermTuple<'world>,
{
    inner: FlexibleQuery<'world, MAX_TERM_CNT>,
    _pd: PhantomData<TermsT>,
}

impl<'world, TermsT> Query<'world, TermsT>
where
    TermsT: TermTuple<'world>,
{
    /// Iterates over the entities matching this query, the iterator item being the entity
    /// components.
    #[must_use]
    pub fn iter<'this>(
        &'this self,
    ) -> Iter<'this, 'world, TermsT, FlexibleQueryIter<'this, 'world>>
    {
        tracing::trace!("Searching for {}", std::any::type_name::<TermsT>());

        Iter {
            world: self.inner.world(),
            inner: self.inner.iter(),
            comps_pd: PhantomData,
        }
    }

    /// Iterates over the entities matching this query, the iterator item being the entity
    /// [`Uid`] and the matching entity components.
    #[must_use]
    pub fn iter_with_euids<'this>(
        &'this self,
    ) -> ComponentAndEuidIter<'this, 'world, TermsT, FlexibleQueryIter<'this, 'world>>
    {
        tracing::trace!("Searching for {}", std::any::type_name::<TermsT>());

        ComponentAndEuidIter {
            world: self.inner.world(),
            iter: self.inner.iter(),
            comps_pd: PhantomData,
        }
    }

    /// Iterates over the entities matching this query using the iterator returned by
    /// `func`.
    ///
    /// This function exists so that a custom [`EntityHandle`] iterator can be given to
    /// [`Iter`] without giving the user access to a reference to the [`World`].
    #[must_use]
    pub fn iter_with<'this, OutIter>(
        &'this self,
        func: impl FnOnce(FlexibleQueryIter<'this, 'world>) -> OutIter,
    ) -> Iter<'this, 'world, TermsT, OutIter>
    where
        OutIter: Iterator<Item = EntityHandle<'world>>,
    {
        tracing::trace!("Searching for {}", std::any::type_name::<TermsT>());

        Iter {
            world: self.inner.world(),
            inner: func(self.inner.iter()),
            comps_pd: PhantomData,
        }
    }

    /// Returns the UID of the entity at the given query iteration index.
    #[must_use]
    pub fn get_entity_uid(&self, entity_index: usize) -> Option<Uid>
    {
        Some(self.inner.iter().nth(entity_index)?.uid())
    }

    /// Returns a new `Query` created from a [`FlexibleQuery`].
    ///
    /// # Important notes
    /// The terms in `TermsT` must be compatible with the terms
    /// in the given [`FlexibleQuery`], otherwise any method call or iterating might
    /// panic.
    #[must_use]
    pub fn from_flexible_query(
        flexible_query: FlexibleQuery<'world, MAX_TERM_CNT>,
    ) -> Self
    {
        // TODO: Check compatability of terms

        Self {
            inner: flexible_query,
            _pd: PhantomData,
        }
    }

    pub fn into_flexible_query(self) -> FlexibleQuery<'world, MAX_TERM_CNT>
    {
        self.inner
    }

    pub(crate) fn new(world: &'world World) -> Self
    {
        let mut terms_builder = Terms::builder();

        TermsT::apply_terms_to_builder(&mut terms_builder);

        Self {
            inner: world.flexible_query(terms_builder.build()),
            _pd: PhantomData,
        }
    }
}

impl<'query, 'world, TermsT> IntoIterator
    for &'query Query<'world, TermsT>
where
    TermsT: TermTuple<'world>,
{
    type IntoIter = Iter<'query, 'world, TermsT, FlexibleQueryIter<'query, 'world>>;
    type Item = TermsT::Fields;

    fn into_iter(self) -> Self::IntoIter
    {
        self.iter()
    }
}

impl<'world, TermsT> SystemParam<'world>
    for Query<'world, TermsT>
where
    TermsT: TermTuple<'world>,
{
    type Input = ();

    fn new(world: &'world World, _system_metadata: &SystemMetadata) -> Self
    {
        Self::new(world)
    }
}

#[derive(Debug)]
pub struct Terms<const MAX_TERM_CNT: usize>
{
    present: ArrayVec<Uid, MAX_TERM_CNT>,
    absent: ArrayVec<Uid, MAX_TERM_CNT>,
}

impl<const MAX_TERM_CNT: usize> Terms<MAX_TERM_CNT>
{
    pub fn builder() -> TermsBuilder<MAX_TERM_CNT>
    {
        TermsBuilder::default()
    }
}

#[derive(Debug, Default)]
#[must_use]
pub struct TermsBuilder<const MAX_TERM_CNT: usize>
{
    present: ArrayVec<Uid, MAX_TERM_CNT>,
    absent: ArrayVec<Uid, MAX_TERM_CNT>,
}

#[allow(clippy::return_self_not_must_use)]
pub trait TermsBuilderInterface
{
    fn present(self, ids: impl Array<Uid>) -> Self;

    fn absent(self, ids: impl Array<Uid>) -> Self;
}

macro_rules! impl_terms_builder {
    ($($impl_content: tt)*) => {
        impl<const MAX_TERM_CNT: usize>
            TermsBuilderInterface for TermsBuilder<MAX_TERM_CNT>
        {
            $($impl_content)*
        }

        impl<const MAX_TERM_CNT: usize>
            TermsBuilderInterface for &mut TermsBuilder<MAX_TERM_CNT>
        {
            $($impl_content)*
        }
    };
}

impl_terms_builder! {
    #[allow(unused_mut)]
    fn present(mut self, mut ids: impl Array<Uid>) -> Self
    {
        if !ids.as_ref().is_sorted() {
            ids.as_mut().sort();
        }

        if self.present.is_empty() {
            self.present.extend(ids);
            return self;
        }

        let mut id_iter = ids.into_iter();

        while let Some(id) = id_iter.next() {
            let insert_index = self.present
                .partition_point(|other_id| *other_id <= id);

            if insert_index == self.present.len() {
                self.present.extend([id].into_iter().chain(id_iter));

                return self;
            }

            self.present
                .insert(insert_index, id);

        }

        self
    }

    #[allow(unused_mut)]
    fn absent(mut self, mut ids: impl Array<Uid>) -> Self
    {
        if !ids.as_ref().is_sorted() {
            ids.as_mut().sort();
        }

        if self.absent.is_empty() {
            self.absent.extend(ids);
            return self;
        }

        let mut id_iter = ids.into_iter();

        while let Some(id) = id_iter.next() {
            let insert_index = self.absent
                .partition_point(|other_id| *other_id <= id);

            if insert_index == self.absent.len() {
                self.absent.extend([id].into_iter().chain(id_iter));

                return self;
            }

            self.absent
                .insert(insert_index, id);

        }

        self
    }
}

impl<const MAX_TERM_CNT: usize> TermsBuilder<MAX_TERM_CNT>
{
    #[must_use]
    pub fn build(self) -> Terms<MAX_TERM_CNT>
    {
        debug_assert!(self.present.is_sorted());
        debug_assert!(self.absent.is_sorted());

        Terms {
            present: self.present,
            absent: self.absent,
        }
    }
}

pub trait Term<'world>
{
    type AddField<Fields: Tuple>;

    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
    );

    fn add_field<Fields: Tuple>(
        entity_handle: &EntityHandle<'world>,
        world: &'world World,
        fields: Fields,
    ) -> Self::AddField<Fields>;
}

impl<'world, ComponentT: Component> Term<'world> for &ComponentT
{
    type AddField<Fields: Tuple> = Fields::WithElementAtEnd<ComponentHandle<'world, ComponentT>>;

    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
    )
    {
        terms_builder.present([ComponentT::id()]);
    }

    fn add_field<Fields: Tuple>(
        entity_handle: &EntityHandle<'world>,
        _world: &'world World,
        fields: Fields,
    ) -> Self::AddField<Fields>
    {
        assert!(!ComponentT::id().is_pair());

        let Some(component) = entity_handle
            .get_matching_components(ComponentT::id())
            .next()
        else {
            panic!(
                concat!(
                    "Component {} was not found in entity {}. There ",
                    "is most likely a bug in the entity querying"
                ),
                type_name::<ComponentT>(),
                entity_handle.uid()
            );
        };

        let component = match ComponentHandle::<ComponentT>::from_entity_component_ref(&component) {
            Ok(component) => component,
            Err(err) => {
                panic!(
                    "Creating handle to component {} failed: {err}",
                    type_name::<ComponentT>()
                );
            }
        };

        fields.with_elem(component)
    }
}

impl<'world, ComponentT: Component> Term<'world> for &mut ComponentT
{
    type AddField<Fields: Tuple> = Fields::WithElementAtEnd<ComponentHandleMut<'world, ComponentT>>;

    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
    )
    {
        terms_builder.present([ComponentT::id()]);
    }

    fn add_field<Fields: Tuple>(
        entity_handle: &EntityHandle<'world>,
        world: &'world World,
        fields: Fields,
    ) -> Self::AddField<Fields>
    {
        assert!(!ComponentT::id().is_pair());

        let Some(component) = entity_handle
            .get_matching_components(ComponentT::id())
            .next()
        else {
            panic!(
                concat!(
                    "Component {} was not found in entity {}. There ",
                    "is most likely a bug in the entity querying"
                ),
                type_name::<ComponentT>(),
                entity_handle.uid()
            );
        };

        let component = match ComponentHandleMut::<ComponentT>::from_entity_component_ref(&component, world) {
            Ok(component) => component,
            Err(err) => {
                panic!(
                    "Creating mut handle to component {} failed: {err}",
                    type_name::<ComponentT>()
                );
            }
        };

        fields.with_elem(component)
    }
}

impl<'world, TermT, FieldAcc> TermFieldSource<'world, FieldAcc> for TermT
where 
    TermT: Term<'world>,
    TermT::AddField<FieldAcc>: Tuple,
    FieldAcc: Tuple
{
    type NewFieldAcc = TermT::AddField<FieldAcc>;

    fn collect_field(
        entity_handle: &EntityHandle<'world>,
        world: &'world World,
        fields: FieldAcc,
    ) -> Self::NewFieldAcc
    {
        Self::add_field(entity_handle, world, fields)
    }
}

pub trait TermTuple<'world>
{
    type Fields;

    fn apply_terms_to_builder<const MAX_TERM_CNT: usize>(
        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
    );

    fn get_fields(
        entity_handle: &EntityHandle<'world>,
        world: &'world World,
    ) -> Self::Fields;
}

pub struct Iter<'query, 'world, TermsT, EntityHandleIter>
where
    TermsT: TermTuple<'world>,
    EntityHandleIter: Iterator<Item = EntityHandle<'world>>,
{
    world: &'world World,
    inner: EntityHandleIter,
    comps_pd: PhantomData<(TermsT, &'query ())>,
}

impl<'query, 'world, TermsT, EntityHandleIter> Iterator
    for Iter<'query, 'world, TermsT, EntityHandleIter>
where
    TermsT: TermTuple<'world>,
    EntityHandleIter: Iterator<Item = EntityHandle<'world>>,
{
    type Item = TermsT::Fields;

    fn next(&mut self) -> Option<Self::Item>
    {
        let entity_handle = self.inner.next()?;

        Some(TermsT::get_fields(&entity_handle, self.world))
    }
}

pub struct ComponentAndEuidIter<'query, 'world, TermsT, EntityHandleIter>
where
    TermsT: TermTuple<'world>,
    EntityHandleIter: Iterator<Item = EntityHandle<'world>>,
{
    world: &'world World,
    iter: EntityHandleIter,
    comps_pd: PhantomData<(TermsT, &'query ())>,
}

impl<'query, 'world, TermsT, EntityHandleIter> Iterator
    for ComponentAndEuidIter<'query, 'world, TermsT, EntityHandleIter>
where
    TermsT: TermTuple<'world>,
    EntityHandleIter: Iterator<Item = EntityHandle<'world>>,
{
    type Item = (Uid, TermsT::Fields);

    fn next(&mut self) -> Option<Self::Item>
    {
        let entity_handle = self.iter.next()?;

        Some((
            entity_handle.uid(),
            TermsT::get_fields(&entity_handle, self.world),
        ))
    }
}

pub trait TermFieldSource<'world, FieldAcc>
{
    type NewFieldAcc;

    fn collect_field(
        entity_handle: &EntityHandle<'world>,
        world: &'world World,
        fields: FieldAcc,
    ) -> Self::NewFieldAcc;
}

macro_rules! term_field_source_new_field_acc {
    (overflow) => {
        ()
    };

    ($index: tt) => {
        paste! {
            [<Term $index>]::NewFieldAcc
        }
    };
}

macro_rules! gen_term_tuple_impls {
    ($c: tt) => {
        seq!(I in 0..$c {
            impl<'world, #(Term~I,)*> TermTuple<'world> for (#(Term~I,)*)
            where
                #(
                    Term~I: Term<'world> + TermFieldSource<
                        'world,
                        sub!(I - 1, term_field_source_new_field_acc),
                        NewFieldAcc: Tuple
                    >,
                )*
            {
                type Fields = sub!($c - 1, term_field_source_new_field_acc);

                #[allow(unused)]
                fn apply_terms_to_builder<const MAX_TERM_CNT: usize>(
                    terms_builder: &mut TermsBuilder<MAX_TERM_CNT>
                )
                {
                    #(
                        Term~I::apply_to_terms_builder(terms_builder);
                    )*
                }

                #[allow(unused)]
                fn get_fields(
                    entity_handle: &EntityHandle<'world>,
                    world: &'world World,
                ) -> Self::Fields
                {
                    let fields = ();

                    #(
                        let fields = Term~I::collect_field(entity_handle, world, fields);
                    )*

                    fields
                }
            }
        });
    };
}

seq!(C in 0..17 {
    gen_term_tuple_impls!(C);
});