use std::usize;
use std::mem;
use std::hash::Hash;
use std::ops::Deref;

use crate::storage::{Storage, IntoIter, IntoIterMut};
use crate::sync::{ReadGuardRef, WriteGuardRef};
use densevec::{self, DenseVec};
use crate::utils::*;
use crossbeam_skiplist::SkipSet;

pub struct UniqueDenseVec<T> {
    storage: DenseVec<T>,
    unique: SkipSet<u32>,
}

pub struct RefMut<'a, T>{
    value: &'a mut T,
    unique: &'a SkipSet<u32>,
}

impl<'a, T> Deref for RefMut<'a, T>{
    type Target = T;
    fn deref(&self) -> &T {
        self.value
    }
}

impl<'a, T: Hash + Eq> RefMut<'a, T> {
    pub fn set(&mut self, t: T) {
        if *self.value != t {
            self.unique.remove(&fxhash::hash32(self.value));
            let new_hash = fxhash::hash32(&t);
            if self.unique.contains(&new_hash) {
                panic!("Trying to store non unique value on a unique storage")
            }
            self.unique.insert(new_hash);
        }
        *self.value = t;
    }
}

impl<'a, T: 'a> Storage<'a, T> for UniqueDenseVec<T>
where T: Hash
{
    type Get = &'a T;
    type GetMut = RefMut<'a, T>;
    type DerefTarget = T;
    type IdedIter = densevec::Iter<'a, usize, T>;
    type Iter = densevec::Values<'a, T>;
    type IterMut = UniqueIterMut<'a, T>;

    #[inline]
    fn new() -> UniqueDenseVec<T>{
        UniqueDenseVec{
            storage: DenseVec::default(),
            unique: SkipSet::default()
        }
    }

    #[inline]
    fn with_capacity(capacity: usize) -> Self{
        UniqueDenseVec{
            storage: DenseVec::with_capacity(capacity),
            unique: SkipSet::new()
        }
    }

    #[inline]
    fn insert(&mut self, guid: usize, t: T){
        let hash = fxhash::hash32(&t);
        if self.unique.contains(&hash) {
            panic!("Trying to store non unique value on a unique storage")
        }
        self.storage.insert(guid, t);
        self.unique.insert(hash);
    }

    #[inline]
    fn remove(&mut self, guid: usize){
        let t = self.storage.remove(guid).unwrap();
        self.unique.remove(&fxhash::hash32(&t));
    }

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

    #[inline]
    unsafe fn get_mut(&mut self, guid: usize) -> Self::GetMut {
        let value = delete_lifetime_mut(self.storage.get_unchecked_mut(guid));
        let unique = delete_lifetime_mut(&mut self.unique);
        RefMut{ value, unique }
    }

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

    #[inline]
    unsafe fn fast_get_mut(&mut self, idx: usize) -> Self::GetMut{
        let value = delete_lifetime_mut(self.storage.get_fast_unchecked_mut(idx));
        let unique = delete_lifetime_mut(&mut self.unique);
        RefMut{ value, unique }
    }

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

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

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

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

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

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

pub struct UniqueIterMut<'a, T: 'a>{
    unique: &'a SkipSet<u32>,
    iter: densevec::ValuesMut<'a, T>
}

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

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

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

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

impl<'a, T: 'a> Iterator for UniqueIntoIter<'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 UniqueIntoIter<'a, T>{
    #[inline]
    fn len(&self) -> usize {
        self.iter.len()
    }
}

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

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

impl<'a, T: 'a> Iterator for UniqueIntoIterMut<'a, T>{
    type Item = RefMut<'a, T>;
    #[inline]
    fn next(&mut self) -> Option<RefMut<'a, T>>{
        self.iter.next().map(|value| RefMut{
            value,
            unique: unsafe{ delete_lifetime(&self._guard.unique) }
        })
    }

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

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

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


// #[cfg(feature = "parallel_iter")]
// impl<'a, T: 'a> ParStorage<'a, T> for UniqueDenseVec<T>
// where
//     T: Hash + Eq + Sync + Send,
//     Self::Get: Send,
//     Self::GetMut: Send
// {
//     type ParIter = densevec::ParValues<'a, T>;
//     type ParIterMut = UniqueParIterMut<'a, T>;

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

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


// #[cfg(feature = "parallel_iter")]
// pub struct UniqueParIterMut{}

// 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,
//         }
//     }
// }