//! Low-level querying.
use std::iter::{repeat_n, Filter, FlatMap, RepeatN, Zip};

use crate::component::storage::archetype::{Archetype, ArchetypeEntity, EntityIter};
use crate::component::storage::{ArchetypeRefIter, Storage as ComponentStorage};
use crate::lock::ReadGuard;
use crate::query::options::Options;
use crate::query::Terms;
use crate::uid::Uid;
use crate::{EntityComponent, World};

/// Low-level entity query structure.
#[derive(Debug)]
pub struct Query<'world, 'terms>
{
    component_storage: ReadGuard<'world, ComponentStorage>,
    terms: Terms<'terms>,
}

impl<'world, 'terms> Query<'world, 'terms>
{
    /// Iterates over the entities matching this query.
    #[must_use]
    pub fn iter<OptionsT: Options>(&self) -> Iter<'_>
    {
        Iter {
            iter: self
                .component_storage
                .search_archetypes(self.terms.required_components.as_ref())
                .flat_map(
                    (|archetype| {
                        repeat_n(archetype, archetype.entity_cnt())
                            .zip(archetype.entities())
                    }) as ComponentIterMapFn,
                )
                .filter(|(_, entity)| OptionsT::entity_filter(&entity.components)),
        }
    }

    pub(crate) fn new(world: &'world World, terms: Terms<'terms>) -> Self
    {
        Self {
            component_storage: world
                .data
                .component_storage
                .read_nonblock()
                .expect("Failed to acquire read-only component storage lock"),
            terms,
        }
    }
}

pub struct Iter<'query>
{
    iter: QueryEntityIter<'query>,
}

impl<'query> Iterator for Iter<'query>
{
    type Item = EntityHandle<'query>;

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

        Some(EntityHandle { archetype, entity })
    }
}

pub struct EntityHandle<'query>
{
    archetype: &'query Archetype,
    entity: &'query ArchetypeEntity,
}

impl<'query> EntityHandle<'query>
{
    /// Returns the [`Uid`] of this entity.
    #[inline]
    #[must_use]
    pub fn uid(&self) -> Uid
    {
        self.entity.uid
    }

    #[inline]
    #[must_use]
    pub fn components(&self) -> &'query [EntityComponent]
    {
        &self.entity.components
    }

    #[inline]
    #[must_use]
    pub fn get_component_index(&self, component_uid: Uid) -> Option<usize>
    {
        self.archetype.get_index_for_component(component_uid)
    }
}

type ComponentIterMapFnOutput<'a> = Zip<RepeatN<&'a Archetype>, EntityIter<'a>>;

type ComponentIterMapFn = for<'a> fn(&'a Archetype) -> ComponentIterMapFnOutput<'a>;

type ComponentIterFilterFn =
    for<'a, 'b> fn(&'a (&'b Archetype, &'b ArchetypeEntity)) -> bool;

type QueryEntityIter<'query> = Filter<
    FlatMap<
        ArchetypeRefIter<'query>,
        ComponentIterMapFnOutput<'query>,
        ComponentIterMapFn,
    >,
    ComponentIterFilterFn,
>;