use std::marker;
use crate::{
    entity::{EntitiesStorage, Entity},
    storage::{IntoSendStorage, FastIndexExt, ReadOnlyStorage}
};
use super::{DataAccesses, FromComponent, SafeIter, UnorderedData};
use crate::storage::StorageRef;
use crate::bitmask::{Bitmask, MaskType};
use std::ops::Deref;
#[cfg(feature = "parallel_iter")]
use rayon::prelude::*;
#[cfg(feature = "parallel_iter")]
use rayon::iter::plumbing::UnindexedConsumer;
use std::usize;
use std::any::TypeId;
#[cfg(components_64)]
use num_traits::Zero;

/// Operator that matches every entity no matter if it has the component or not
/// but doesn't give access to the component, only returns a boolean specifying
/// if the component is present or not.
///
/// This doesn't lock the accessed component so it can be used in parallel even with write access
/// operators
///
/// ```
/// # #[macro_use] extern crate rinecs_derive;
/// # use rinecs::*;
/// # #[derive(Component, Debug)]
/// # struct Position{x: f32, y: f32}
/// # #[derive(Component, Debug)]
/// # struct Velocity{x: f32, y: f32}
/// # let mut world = World::new();
/// # let entities = world.entities();
/// for (has_pos, vel) in entities.iter_for::<(HasOption<Position>, Read<Velocity>)>(){
///     if has_pos {
///         // ...
///     }
/// }
/// ```
///
/// Will select all entities that optionally have Position and have a Velocity component
/// pos will be false for those that don't have Position
pub struct HasOption<T: 'static> {
    has: bool,
    _marker: marker::PhantomData<T>
}


impl<'a, T: 'static> FromComponent<'a, bool> for HasOption<T> {
    fn from_component(has: bool) -> HasOption<T>{
        HasOption{
            has,
            _marker: marker::PhantomData,
        }
    }
}

impl<T:  'static> Deref for HasOption<T> {
    type Target = bool;
    fn deref(&self) -> &bool{
        &self.has
    }
}

pub struct IterHasOption<'a, T> {
    ptr: *const (Entity, MaskType),
    end: *const (Entity, MaskType),
    storage: StorageHasOption<'a, T>,
}


impl<'a, T> Iterator for IterHasOption<'a, T>
where T: 'static,
{
    type Item = bool;
    #[inline]
    fn next(&mut self) -> Option<bool>{
        while self.ptr != self.end {
            unsafe {
                let e = &(*self.ptr).0;
                self.ptr = self.ptr.add(1);
                if e.guid != usize::MAX {
                    return Some(self.storage.get_unchecked(e.guid));
                }
            }
        }

        None
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let len = self.end as usize - self.ptr as usize;
        (0, Some(len))
    }
}

pub struct StorageHasOption<'a, T> {
    entities_masks: &'a [(Entity, MaskType)],
    component_mask: MaskType,
    _marker_t: marker::PhantomData<T>,
}

impl<'a, 'r, T> FastIndexExt for StorageHasOption<'a, T>
where T: 'static,
{
    type FastIndex = bool;
    type StaticTypeId = HasOption<T>;

    fn fast_index(&self, guid: usize) -> bool {
        self.entities_masks[guid].1.clone() & self.component_mask.clone() != MaskType::zero()
    }
}

impl<'a, 'r, T> StorageRef<'r> for StorageHasOption<'a, T>
where T: 'static,
{
    type Data = HasOption<T>;
    type Component = bool;

    unsafe fn get_fast_unchecked(&mut self, idx: bool) -> bool{
        idx
    }

    unsafe fn get_unchecked(&mut self, guid: usize) -> bool{
        self.entities_masks[guid].1.clone() & self.component_mask.clone() != MaskType::zero()
    }

    fn contains(&self, _guid: usize) -> bool{
        true
    }
}

impl<'a, 'r, T: 'static> IntoSendStorage<'r> for StorageHasOption<'a, T> {
    type SendStorage = StorageHasOption<'a, T>;

    fn into_send_storage(&'r mut self) -> Self::SendStorage {
        StorageHasOption{
            entities_masks: self.entities_masks,
            component_mask: self.component_mask.clone(),
            _marker_t: marker::PhantomData,
        }
    }
}

unsafe impl<'a, T> ReadOnlyStorage for StorageHasOption<'a, T>{}

impl<'a, T: 'static> StorageHasOption<'a, T> {
    pub fn iter<'i>(&'i mut self) -> IterHasOption<'a, T> {
        IterHasOption{
            ptr: self.entities_masks.as_ptr(),
            end: unsafe{ self.entities_masks.as_ptr().add(self.entities_masks.len()) },
            storage: self.into_send_storage(),
        }
    }
}

#[cfg(feature = "parallel_iter")]
impl<'a, T> StorageHasOption<'a, T> {
    pub fn par_iter<'i>(&'i mut self) -> HasOptionParIter<'i> {
        HasOptionParIter::new(self.entities_masks, self.component_mask.clone())
    }
}

unsafe impl<T> SafeIter<'_> for HasOption<T> {}

impl<'a, T:  'static> UnorderedData<'a> for HasOption<T> {
    type Iter = IterHasOption<'a, T>;
    type IterMut = IterHasOption<'a, T>;
    type Components = T;
    type ComponentsRef = bool;
    type Storage = StorageHasOption<'a, T>;

    fn query_mask<E: EntitiesStorage>(_: &E) -> Bitmask {
        crate::Bitmask::all()
    }

    fn into_iter<E: EntitiesStorage>(entities: &'a E) -> Self::Iter {
        let storage = <Self as UnorderedData>::storage(entities).unwrap();
        IterHasOption {
            ptr: storage.entities_masks.as_ptr(),
            end: unsafe{ storage.entities_masks.as_ptr().add(storage.entities_masks.len()) },
            storage,
        }
    }

    fn into_iter_mut<E: EntitiesStorage>(entities: &'a E) -> Self::Iter {
        Self::into_iter(entities)
    }

    fn storage<E: EntitiesStorage>(entities: &'a E) -> Option<Self::Storage> {
        let entities_masks = entities.entities_ref();
        let component_mask = entities.component_mask::<T>();
        Some(StorageHasOption{
            entities_masks,
            component_mask,
            _marker_t: marker::PhantomData,
        })
    }
}

impl<T: 'static> DataAccesses for HasOption<T> {
    fn reads() -> Vec<TypeId>{ vec![] }
    fn writes() -> Vec<TypeId>{ vec![] }
}

#[cfg(feature = "parallel_iter")]
pub struct HasOptionParIter<'a>{
    entities_masks: &'a [(Entity, MaskType)],
    component_mask: MaskType,
}

#[cfg(feature = "parallel_iter")]
impl<'a> HasOptionParIter<'a>{
    pub fn new(entities_masks: &'a [(Entity, MaskType)], component_mask: MaskType) -> HasOptionParIter<'a>{
        HasOptionParIter{
            entities_masks,
            component_mask,
        }
    }
}

#[cfg(feature = "parallel_iter")]
impl<'a> ParallelIterator for HasOptionParIter<'a> {
    type Item = bool;

    #[inline]
    fn drive_unindexed<C>(self, consumer: C) -> C::Result
        where C: UnindexedConsumer<Self::Item>
    {
        let component_mask = self.component_mask.clone();
        self.entities_masks.par_iter()
            .map(move |(_,mask)| mask & component_mask.clone() != MaskType::zero())
            .drive_unindexed(consumer)
    }
}