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,
    ArchetypeRefIter,
    Storage as ComponentStorage,
};
use crate::component::{Metadata as ComponentMetadata, Sequence as ComponentSequence};
use crate::lock::{Lock, ReadGuard};
use crate::query::options::Options;
use crate::system::{
    NoInitParamFlag as NoInitSystemParamFlag,
    Param as SystemParam,
    System,
};
use crate::{EntityComponent, World, WorldData};

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.components.as_slice()) as ComponentIterMapFn)
                .flatten()
                .filter(|components| OptionsT::entity_filter(*components)),
            comps_pd: PhantomData,
        }
    }

    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() })
    }

    fn prepare(world_data: &WorldData)
    {
        let mut component_storage_lock = world_data
            .component_storage
            .write_nonblock()
            .expect("Failed to acquire read-write component storage lock");

        #[cfg(feature = "debug")]
        tracing::debug!(
            "Adding archetypes lookup entry for components: ({})",
            std::any::type_name::<Comps>()
        );

        component_storage_lock.add_archetype_lookup_entry(Comps::metadata());
    }
}

type ComponentIterMapFn = for<'a> fn(&'a Archetype) -> &'a [Vec<EntityComponent>];

type ComponentIterFilterFn = for<'a, 'b> fn(&'a &'b Vec<EntityComponent>) -> 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()?.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))
    }
}