/*!
Simple persistent generic HashMap/Key-value store, using the Persy Index API.

This is in a beta state at the moment.

 usage:

```
use persawkv::XKV;
let test_store = persawkv::SingleKV::<String, String>::new("./raw.cab", "runint").unwrap();

let _ = test_store.insert("key".to_string(), "value".to_string());
println!("{:?}", test_store.get(&"key".to_string()));
let _ = test_store.remove("key".to_string());

# let _ = std::fs::remove_file("./raw.cab");
```
*/

#![deny(missing_docs)]
#![forbid(unsafe_code)]

pub use persy::PRes;
use persy::{IndexType, Persy, PersyError};
use std::{borrow::Cow, marker::PhantomData, ops::RangeBounds};

mod private {
    // mark traits as sealed
    pub trait Sealed {
    }
}

/// The type that represents a key--(value mode generic)-value store
pub struct BaseKV<K, V>(
    Persy,
    Cow<'static, str>,
    persy::ValueMode,
    PhantomData<(K, V)>,
);

/// The type that represents a key--multiple-value store
pub struct MultiKV<K, V>(BaseKV<K, V>);

/// The type that represents a key-value store
pub struct SingleKV<K, V>(BaseKV<K, V>);

impl<K, V> Clone for BaseKV<K, V> {
    fn clone(&self) -> Self {
        BaseKV(self.0.clone(), self.1.clone(), self.2.clone(), PhantomData)
    }
}
impl<K, V> private::Sealed for BaseKV<K, V> { }

impl<K, V> Clone for MultiKV<K, V> {
    fn clone(&self) -> Self {
        MultiKV(self.0.clone())
    }
}
impl<K, V> private::Sealed for MultiKV<K, V> { }

impl<K, V> Clone for SingleKV<K, V> {
    fn clone(&self) -> Self {
        SingleKV(self.0.clone())
    }
}
impl<K, V> private::Sealed for SingleKV<K, V> { }

/// This type represents a key-..-value iterator
pub struct Iter<K, V>(persy::IndexIter<K, V>)
where
    K: IndexType,
    V: IndexType;

impl<K, V> Iterator for Iter<K, V>
where
    K: IndexType,
    V: IndexType,
{
    type Item = (K, persy::Value<V>);
    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.0.next()
    }
}

/// This type represents a keys iterator
pub struct KeysIter<K, V>(std::iter::Map<persy::IndexIter<K, V>, fn((K, persy::Value<V>)) -> K>)
where
    K: IndexType,
    V: IndexType;

impl<K, V> Iterator for KeysIter<K, V>
where
    K: IndexType,
    V: IndexType,
{
    type Item = K;
    #[inline]
    fn next(&mut self) -> Option<K> {
        self.0.next()
    }
}

/// Abstract over derived ..KV types
pub trait XKV<K, V> : private::Sealed
where
    K: IndexType,
    V: IndexType,
{
    /// Provides access to the underlying BaseKV
    #[doc(hidden)]
    fn underlying_base_kv(&self) -> &BaseKV<K, V>;

    /// Inserts a key, value pair into the KV store
    #[inline]
    fn insert(&self, key: K, value: V) -> PRes<()> {
        self.underlying_base_kv().insert(key, value)
    }

    /// Removes a key and associated value from the KV store
    #[inline]
    fn remove(&self, key: K) -> PRes<()> {
        self.underlying_base_kv().remove(key)
    }

    /// Removes all entries from the KV store
    #[inline]
    fn clear(&self) -> PRes<()> {
        self.underlying_base_kv().clear()
    }

    /// Gets all the keys contained in the KV store
    #[inline]
    fn keys(&self) -> PRes<KeysIter<K, V>> {
        self.underlying_base_kv().keys()
    }
}

impl<K, V> XKV<K, V> for MultiKV<K, V>
where
    K: IndexType,
    V: IndexType,
{
    #[doc(hidden)]
    fn underlying_base_kv(&self) -> &BaseKV<K, V> {
        &self.0
    }
}

impl<K, V> XKV<K, V> for SingleKV<K, V>
where
    K: IndexType,
    V: IndexType,
{
    #[doc(hidden)]
    fn underlying_base_kv(&self) -> &BaseKV<K, V> {
        &self.0
    }
}

fn first_of2<A, B>(x: (A, B)) -> A {
    x.0
}

impl<K, V> BaseKV<K, V>
where
    K: IndexType,
    V: IndexType,
{
    /// Creates a new instance of the value-mode-generic KV store
    pub fn new(p: &str, idxn: impl Into<Cow<'static, str>>, vm: persy::ValueMode) -> PRes<Self> {
        Self::new_intern(p, idxn.into(), vm)
    }

    pub(crate) fn new_intern(p: &str, idxn: Cow<'static, str>, vm: persy::ValueMode) -> PRes<Self> {
        match Persy::create(p) {
            Ok(_) => {}
            Err(PersyError::Io(ref e)) if e.kind() == std::io::ErrorKind::AlreadyExists => {}
            Err(e) => return Err(e),
        }

        let persy = Persy::open(p, persy::Config::new())?;
        let ridxn = idxn.as_ref();

        if !persy.exists_index(ridxn)? {
            let mut tx = persy.begin()?;
            persy.create_index::<K, V>(&mut tx, ridxn, vm.clone())?;
            let prepared = persy.prepare_commit(tx)?;
            persy.commit(prepared)?;
        }

        Ok(BaseKV(persy, idxn, vm, PhantomData))
    }

    /// Inserts a key, value pair into the KV store
    pub fn insert(&self, key: K, value: V) -> PRes<()> {
        let mut tx = self.0.begin()?;
        self.0.put::<K, V>(&mut tx, self.1.as_ref(), key, value)?;
        let prepared = self.0.prepare_commit(tx)?;
        self.0.commit(prepared)
    }

    /// Removes a key and associated value from the KV store
    pub fn remove(&self, key: K) -> PRes<()> {
        let mut tx = self.0.begin()?;
        self.0.remove::<K, V>(&mut tx, self.1.as_ref(), key, None)?;
        let prepared = self.0.prepare_commit(tx)?;
        self.0.commit(prepared)
    }

    /// Removes all entries from the KV store
    pub fn clear(&self) -> PRes<()> {
        let mut tx = self.0.begin()?;
        self.0.drop_index(&mut tx, self.1.as_ref())?;
        self.0
            .create_index::<K, V>(&mut tx, self.1.as_ref(), self.2.clone())?;
        let prepared = self.0.prepare_commit(tx)?;
        self.0.commit(prepared)
    }

    /// Gets all the keys contained in the KV store
    #[inline]
    pub fn keys(&self) -> PRes<KeysIter<K, V>> {
        Ok(KeysIter(self.range(..)?.0.map(first_of2)))
    }

    /// Gets the associated value from a key
    pub fn get(&self, key: &K) -> PRes<Option<persy::Value<V>>> {
        self.0.get::<K, V>(self.1.as_ref(), key)
    }

    /// Returns an iterator visiting all key-value pairs inside the specified range in arbitrary order
    pub fn range<R>(&self, r: R) -> PRes<Iter<K, V>>
    where
        R: RangeBounds<K>,
    {
        self.0.range::<K, V, _>(self.1.as_ref(), r).map(Iter)
    }

    /// Returns an iterator visiting all key-value pairs in arbitrary order
    #[inline]
    pub fn iter(&self) -> PRes<Iter<K, V>> {
        self.range(..)
    }
}

fn sharpen_value<V>(v: persy::Value<V>) -> Vec<V> {
    use persy::Value;
    match v {
        Value::CLUSTER(x) => x,
        Value::SINGLE(x) => vec![x],
    }
}

fn flatten_value<V>(v: persy::Value<V>) -> Option<V> {
    use persy::Value;
    match v {
        Value::CLUSTER(x) => x.into_iter().next(),
        Value::SINGLE(x) => Some(x),
    }
}

impl<K, V> MultiKV<K, V>
where
    K: IndexType,
    V: IndexType,
{
    /// Creates a new instance of the MultiKV store
    pub fn new(p: &str, idxn: impl Into<Cow<'static, str>>) -> PRes<Self> {
        Ok(Self(BaseKV::new_intern(
            p,
            idxn.into(),
            persy::ValueMode::CLUSTER,
        )?))
    }

    /// Gets the associated value from a key
    pub fn get(&self, key: &K) -> PRes<Vec<V>> {
        Ok(self.0.get(key)?.map(sharpen_value).unwrap_or_else(Vec::new))
    }

    /// Returns an iterator visiting all key-value pairs in arbitrary order
    pub fn iter(&self) -> PRes<impl Iterator<Item = (K, Vec<V>)>> {
        Ok(self.0.range(..)?.map(|(k, v)| (k, sharpen_value(v))))
    }
}

impl<K, V> SingleKV<K, V>
where
    K: IndexType,
    V: IndexType,
{
    /// Creates a new instance of the SingleKV store
    pub fn new(p: &str, idxn: impl Into<Cow<'static, str>>) -> PRes<Self> {
        Ok(Self(BaseKV::new_intern(
            p,
            idxn.into(),
            persy::ValueMode::REPLACE,
        )?))
    }

    /// Gets the associated value from a key
    pub fn get(&self, key: &K) -> PRes<Option<V>> {
        Ok(self.0.get(key)?.and_then(flatten_value))
    }

    /// Returns an iterator visiting all key-value pairs in arbitrary order
    pub fn iter(&self) -> PRes<impl Iterator<Item = (K, V)>> {
        Ok(self
            .0
            .range(..)?
            .filter_map(|(k, v)| flatten_value(v).map(|v2| (k, v2))))
    }
}