use super::*;
use std::borrow::Borrow;
use std::marker::PhantomData;
use std::iter;
use std::collections::{
    btree_map::Range,
    VecDeque,
};
use smallvec::SmallVec;

#[derive(Debug)]
pub struct StoreSearchIter<'a, T: ?Sized>(&'a Store, Option<Range<'a, String, ArenaIndex>>, VecDeque<&'a sha256::Sha256Hash>, PhantomData<T>);

// Accessing
impl Store
{
    //TODO: Parallelize this with futures::Stream ver to do the `tag_search` lookups in parallel.
    pub fn tag_search_all<'a, T: ?Sized + Ord + 'a>(&'a self, tags: impl IntoIterator<Item= &'a T>) -> impl Iterator<Item = &'a Entry> + 'a
    where String: Borrow<T>
    {
	let tags: SmallVec<[_; 5]> = tags.into_iter().collect();
	
	tags.iter().flat_map(|&tag| self.tag_search(tag)).dedup_ref()
	    .filter(|x| x.tags.iter().map(|x| x.borrow()).filter(|tx| !tags.contains(tx)).count() == 0)

	    /* TODO: get rid of this ,replace `impl Iterator` return with its own type. */ .collect::<Vec<_>>().into_iter()
    }
    /// Search for all entries with *any* of these provided tags.
    ///
    /// # Notes
    /// This is allowed to produce duplicate entries, if either:
    /// * An entry has multiple of the same tag set
    /// * An entry has multiple of the tags provided to this function set
    pub fn tag_search_any<'a, T: ?Sized + Ord + 'a>(&self, tags: impl IntoIterator<Item= &'a T>) -> StoreSearchIter<'_, T>
    where String: Borrow<T>
    {
	let mut sorted: SmallVec<[_; 5]> = tags.into_iter().collect();
	sorted.sort();
	StoreSearchIter(self, Some(match (sorted.first(), sorted.last()) {
	    (Some(&low), Some(&high)) => self.tags.range::<T, _>((std::ops::Bound::Included(low), std::ops::Bound::Included(high))),
	    _ => return StoreSearchIter(self, None, Default::default(), PhantomData),
	}), VecDeque::new(), PhantomData)
    }
    /// Search for all items with this provided tag.
    ///
    /// # Notes
    /// This is allowed to produce duplicate entries, if an entry has two of the same tags set.
    pub fn tag_search<'a, T: ?Sized + Ord>(&'a self, tag: &T) -> StoreSearchIter<'a, T>
    where String: Borrow<T>
    {
	let r= (std::ops::Bound::Included(tag), std::ops::Bound::Included(tag));
	StoreSearchIter(self, Some(self.tags.range::<T, _>(r)), VecDeque::new(), PhantomData)
    }

    fn _assert_test_search(&self)
    {
	let _x: Vec<_> = self.tag_search_any(vec!["hello", "one", "two"]).dedup_ref().collect();
    }
}

impl<'a, T: ?Sized> Iterator for StoreSearchIter<'a, T>
{
    type Item = &'a Entry;
    fn next(&mut self) -> Option<Self::Item>
    {
	if let Some(range) = &mut self.1 {
	    if let Some((_, &ti)) = range.next() {
		// tag index get
		let data_hashes = &self.0.data_hashes;
		let iter = self.0.tag_mappings.get(ti)
		    .map_into_iter()
		    .filter_map(move |&idx| data_hashes.get(idx));
		self.2.extend(iter);
	    }
	} else {
	    return None;
	}
	self.2.pop_front().map(|x| self.0.data.get(x)).flatten()
    }
    fn size_hint(&self) -> (usize, Option<usize>) {
	match self.1 {
	    None => (0, Some(0)),
	    Some(_) => (0, None),
	}
    }
}
impl<'a, T: ?Sized> iter::FusedIterator for StoreSearchIter<'a, T>{}