use std::usize;
use std::mem;

use crate::storage::{Storage, IntoIter, IntoIterMut, IntoIdedIterMut};
#[cfg(feature = "parallel_iter")]
use crate::storage::ParStorage;
use crate::sync::{ReadGuardRef, WriteGuardRef};
use densevec::{self, DenseVec};
use crate::utils::*;

impl<'a, T: 'a> Storage<'a, T> for DenseVec<T>{
    type Get = &'a T;
    type GetMut = &'a mut T;
    type DerefTarget = T;
    type IdedIter = densevec::Iter<'a, usize, T>;
    type Iter = densevec::Values<'a, T>;
    type IterMut = densevec::ValuesMut<'a, T>;

    #[inline]
    fn new() -> DenseVec<T>{
        DenseVec::new()
    }

    #[inline]
    fn with_capacity(capacity: usize) -> Self{
        DenseVec::with_capacity(capacity)
    }

    #[inline]
    fn insert(&mut self, guid: usize, t: T){
        self.insert(guid, t);
    }

    #[inline]
    fn remove(&mut self, guid: usize){
        self.remove(guid).unwrap();
    }

    #[inline]
    unsafe fn get(&self, guid: usize) -> &'a T{
        delete_lifetime(self.get_unchecked(guid))
    }

    #[inline]
    unsafe fn get_mut(&mut self, guid: usize) -> &'a mut T{
        delete_lifetime_mut(self.get_unchecked_mut(guid))
    }

    #[inline]
    unsafe fn fast_get(&self, idx: usize) -> Self::Get{
        delete_lifetime(self.get_fast_unchecked(idx))
    }

    #[inline]
    unsafe fn fast_get_mut(&mut self, idx: usize) -> Self::GetMut{
        delete_lifetime_mut(self.get_fast_unchecked_mut(idx))
    }

    #[inline]
    fn fast_index(&self, guid: usize) -> usize{
        unsafe{ self.fast_index_unchecked_for(guid) }
    }

    #[inline]
    fn guid_from_fast_index(&self, idx: usize) -> usize{
        unsafe{ self.unchecked_guid_from_fast_index(idx) }
    }

    #[inline]
    fn contains(&self, guid: usize) -> bool{
       self.contains_key(guid)
    }

    #[inline]
    fn ided_iter(&self) -> densevec::Iter<'a, usize, T>{
        unsafe{ mem::transmute(self.iter()) }
    }

    #[inline]
    fn iter(&self) -> densevec::Values<'a, T>{
        unsafe{ mem::transmute::<densevec::Values<T>,densevec::Values<'a, T>>(self.values()) }
    }

    #[inline]
    fn iter_mut(&mut self) -> densevec::ValuesMut<'a, T>{
        unsafe{ mem::transmute::<densevec::ValuesMut<T>,densevec::ValuesMut<'a, T>>(self.values_mut()) }
    }
}


#[cfg(feature = "parallel_iter")]
impl<'a, T: 'a> ParStorage<'a, T> for DenseVec<T>
where
    T: Sync + Send,
    <Self as Storage<'a, T>>::Get: Send,
    <Self as Storage<'a, T>>::GetMut: Send
{
    type ParIter = densevec::ParValues<'a, T>;
    type ParIterMut = densevec::ParValuesMut<'a, T>;

    fn par_iter(&self) -> Self::ParIter {
        unsafe{ mem::transmute(self.par_values()) }
    }

    fn par_iter_mut(&mut self) -> Self::ParIterMut {
        unsafe{ mem::transmute(self.par_values_mut()) }
    }
}

pub struct DenseIter<'a, T: 'a>{
    _guard: ReadGuardRef<'a, DenseVec<T>>,
    iter: densevec::Values<'a, T>
}

impl<'a, T: 'a> Iterator for DenseIter<'a, T>{
    type Item = &'a T;
    #[inline]
    fn next(&mut self) -> Option<&'a T>{
        self.iter.next()
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
}

impl<'a, T: 'a> ExactSizeIterator for DenseIter<'a, T>{
    #[inline]
    fn len(&self) -> usize {
        self.iter.len()
    }
}

pub struct DenseIterMut<'a, T: 'a>{
    _guard: WriteGuardRef<'a, DenseVec<T>>,
    iter: densevec::ValuesMut<'a, T>
}

impl<'a, T: 'a> Iterator for DenseIterMut<'a, T>{
    type Item = &'a mut T;
    #[inline]
    fn next(&mut self) -> Option<&'a mut T>{
        self.iter.next()
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
}

impl<'a, T: 'a> ExactSizeIterator for DenseIterMut<'a, T>{
    #[inline]
    fn len(&self) -> usize {
        self.iter.len()
    }
}

impl<'a, T> IntoIter for ReadGuardRef<'a, DenseVec<T>>{
    type Iter = DenseIter<'a, T>;
    fn into_iter(self) -> DenseIter<'a, T>{
        DenseIter{
            iter: unsafe{ mem::transmute::<densevec::Values<T>, densevec::Values<'a,T>>(self.values()) },
            _guard: self,
        }
    }
}

impl<'a, T> IntoIterMut for WriteGuardRef<'a, DenseVec<T>>{
    type IterMut = DenseIterMut<'a, T>;
    fn into_iter_mut(mut self) -> DenseIterMut<'a, T>{
        DenseIterMut{
           iter: unsafe{ mem::transmute::<densevec::ValuesMut<T>, densevec::ValuesMut<'a,T>>(self.values_mut()) },
            _guard: self,
        }
    }
}

pub struct DenseIdedIterMut<'a, T: 'a>{
    _guard: WriteGuardRef<'a, DenseVec<T>>,
    iter: densevec::IterMut<'a, usize, T>
}

impl<'a, T: 'a> Iterator for DenseIdedIterMut<'a, T>{
    type Item = (usize, &'a mut T);
    #[inline]
    fn next(&mut self) -> Option<(usize, &'a mut T)>{
        self.iter.next()
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
}

impl<'a, T: 'a> ExactSizeIterator for DenseIdedIterMut<'a, T>{
    #[inline]
    fn len(&self) -> usize {
        self.iter.len()
    }
}

impl<'a, T> IntoIdedIterMut for WriteGuardRef<'a, DenseVec<T>>{
    type IdedIterMut = DenseIdedIterMut<'a, T>;
    fn into_ided_iter_mut(mut self) -> DenseIdedIterMut<'a, T>{
        DenseIdedIterMut{
            iter:  unsafe{ mem::transmute(self.iter_mut()) },
            _guard: self,
        }
    }
}