use std::any::Any;
use std::collections::HashSet;
use std::iter::{Filter, Flatten, Map};
use std::marker::PhantomData;
use std::sync::Arc;

use crate::component::storage::{
    Archetype,
    ArchetypeEntity,
    ArchetypeRefIter,
    EntityIter,
    Storage as ComponentStorage,
};
use crate::component::{Metadata as ComponentMetadata, Sequence as ComponentSequence};
use crate::entity::Uid as EntityUid;
use crate::lock::{Lock, ReadGuard};
use crate::query::options::Options;
use crate::system::{
    NoInitParamFlag as NoInitSystemParamFlag,
    Param as SystemParam,
    System,
};
use crate::World;

pub mod options;

#[derive(Debug)]
pub struct Query<'world, Comps, OptionsT = ()>
where
    Comps: ComponentSequence,
{
    component_storage: ReadGuard<'world, ComponentStorage>,
    _pd: PhantomData<(Comps, OptionsT)>,
}

impl<'world, Comps, OptionsT> Query<'world, Comps, OptionsT>
where
    Comps: ComponentSequence,
    OptionsT: Options,
{
    /// Iterates over the entities matching this query.
    #[must_use]
    pub fn iter<'this>(&'this self) -> ComponentIter<'world, Comps>
    where
        'this: 'world,
    {
        #[cfg(feature = "debug")]
        tracing::debug!("Searching for {}", std::any::type_name::<Comps>());

        #[allow(clippy::map_flatten)]
        ComponentIter {
            entities: self
                .component_storage
                .find_entities(Comps::metadata())
                .map((|archetype| archetype.entities()) as ComponentIterMapFn)
                .flatten()
                .filter(|entity| OptionsT::entity_filter(entity.components())),
            comps_pd: PhantomData,
        }
    }

    /// Returns the UID of the entity at the given query iteration index.
    pub fn entity_uid(&self, entity_index: usize) -> Option<EntityUid>
    {
        Some(
            self.component_storage
                .find_entities(Comps::metadata())
                .map(|archetype| archetype.entities())
                .flatten()
                .nth(entity_index)?
                .uid(),
        )
    }

    pub(crate) fn new(component_storage: &'world Arc<Lock<ComponentStorage>>) -> Self
    {
        Self {
            component_storage: component_storage
                .read_nonblock()
                .expect("Failed to acquire read-only component storage lock"),
            _pd: PhantomData,
        }
    }
}

impl<'world, Comps, OptionsT> IntoIterator for &'world Query<'world, Comps, OptionsT>
where
    Comps: ComponentSequence,
    OptionsT: Options,
{
    type IntoIter = ComponentIter<'world, Comps>;
    type Item = Comps::Refs<'world>;

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

unsafe impl<'world, Comps, OptionsT> SystemParam<'world>
    for Query<'world, Comps, OptionsT>
where
    Comps: ComponentSequence,
    OptionsT: Options,
{
    type Flags = NoInitSystemParamFlag;
    type Input = ();

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

    fn new<SystemImpl>(
        _system: &'world impl System<'world, SystemImpl>,
        world: &'world World,
    ) -> Self
    {
        Self::new(&world.data.component_storage)
    }

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

        let Some(other_query_component_ids) =
            other_comparable.downcast_ref::<QueryComponentIds>()
        else {
            return true;
        };

        !other_query_component_ids.contains_component_in::<Comps>()
    }

    fn get_comparable() -> Box<dyn Any>
    {
        Box::new(QueryComponentIds { component_ids: Comps::metadata() })
    }
}

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

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

pub struct ComponentIter<'world, Comps>
{
    entities: Filter<
        Flatten<Map<ArchetypeRefIter<'world>, ComponentIterMapFn>>,
        ComponentIterFilterFn,
    >,
    comps_pd: PhantomData<Comps>,
}

impl<'world, Comps> Iterator for ComponentIter<'world, Comps>
where
    Comps: ComponentSequence + 'world,
{
    type Item = Comps::Refs<'world>;

    fn next(&mut self) -> Option<Self::Item>
    {
        Some(Comps::from_components(
            self.entities.next()?.components().iter(),
        ))
    }
}

#[derive(Debug)]
struct QueryComponentIds
{
    component_ids: Vec<ComponentMetadata>,
}

impl QueryComponentIds
{
    fn contains_component_in<OtherComps>(&self) -> bool
    where
        OtherComps: ComponentSequence,
    {
        let other_ids = OtherComps::metadata()
            .into_iter()
            .map(|component_metadata| component_metadata.id)
            .collect::<HashSet<_>>();

        self.component_ids
            .iter()
            .all(|component_metadata| other_ids.contains(&component_metadata.id))
    }
}