use std::debug_assert_eq;
use std::cell::RefCell;
use std::cmp::Eq;
use std::collections::HashMap;
use std::error;
use std::hash::Hash;
use std::marker::PhantomData;
use std::mem;
use std::ops::{Deref, DerefMut};
use std::rc::Rc;

use display_derive::Display;
use typemap::TypeMap;

//#region Persistent
/// A warpper represents managed data. This struct gives exclusive, mutable access to the value.
/// When user want to use some sort of data stored in the DB, it should always be warpped in this type.
/// When the value is dropped, it's stored to a persistent storage.
pub struct Persistent<'store, Key, Value>
where
    Key: Copy + Eq + Hash + 'static,
    Value: 'static,
{
    store: &'store Store,
    key: Key,

    // Can't use a reference to the store because that will lock the entire store.
    // Can't use Rc either because store will hold a Rc to the object as well and thus we can't mutate it.
    // Use Option here so we can swap out the value in Drop. It should never be None. (consider using unsafe for better performance?)
    value: Option<Value>,
}

impl<'store, Key, Value> Persistent<'store, Key, Value>
where
    Key: Copy + Eq + Hash + 'static,
    Value: 'static,
{
    pub fn get_key(&self) -> Key {
        self.key
    }
}

impl<'store, Key, Value> Drop for Persistent<'store, Key, Value>
where
    Key: Copy + Eq + Hash + 'static,
    Value: 'static,
{
    fn drop(&mut self) {
        let value = mem::replace(&mut self.value, None).expect("Internal Error: value should not be None");
        self.store.r#return(self.key, value);
    }
}

impl<'store, Key, Value> Deref for Persistent<'store, Key, Value>
where
    Key: Copy + Eq + Hash + 'static,
    Value: 'static,
{
    type Target = Value;

    fn deref(&self) -> &Self::Target {
        self.value.as_ref().expect("Internal Error: value should not be None.")
    }
}

impl<'store, Key, Value> DerefMut for Persistent<'store, Key, Value>
where
    Key: Copy + Eq + Hash + 'static,
    Value: 'static,
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.value.as_mut().expect("Internal Error: value should not be None.")
    }
}
//#endregion


//#region PersistentRef
/// A warpper represents managed data. This struct gives shared, readonly access to the value.
/// When user want to use some sort of data stored in the DB, it should always be warpped in this type.
/// When the value is dropped, it's stored to a persistent storage.
// We could just use Rc here. It will mostly be the same except it doesn't come with key (which can be solved by returning a tuple).
// However, Rc is an implemenration detail and we don't want to leak it.
#[derive(Clone)]
pub struct PersistentRef<Key, Value>
where
    Key: Copy + Eq + Hash + 'static,
    Value: 'static,
{
    key: Key,

    // Can't use a reference to the store because that will lock the entire store.
    value: Rc<Value>,
}

impl<Key, Value> PersistentRef<Key, Value>
where
    Key: Copy + Eq + Hash + 'static,
    Value: 'static,
{
    pub fn get_key(&self) -> Key {
        self.key
    }
}

impl<Key, Value> Deref for PersistentRef<Key, Value>
where
    Key: Copy + Eq + Hash + 'static,
    Value: 'static,
{
    type Target = Value;

    fn deref(&self) -> &Self::Target {
        &*self.value
    }
}
//#endregion


//#region TypeKey
/// TypeKey
struct TypeKey<Key, Value>(PhantomData<(Key, Value)>);

impl<Key, Value> typemap::Key for TypeKey<Key, Value>
where
    Key: 'static,
    Value: 'static,
{
    type Value = HashMap<Key, State<Value>>;
}

//#endregion

//#region State
/// The state of an item
enum State<Item> {
    InStore(Rc<Item>),
    Locked,
}
//#endregion

//#region ...Error types
#[derive(Debug, Display)]
pub enum StoreError {
    #[display(fmt = "the specified (key, type) pair already exists in the store")]
    Existing,
}

impl error::Error for StoreError {}

#[derive(Debug, Display)]
pub enum LockError {
    #[display(fmt = "the specified (key, type) pair doesn't exist in the store")]
    NotFound,
    #[display(fmt = "the queried item is already locked")]
    Locked,
    #[display(fmt = "the queried item is currently borrowed")]
    Borrowed,
}

impl error::Error for LockError {}

#[derive(Debug, Display)]
pub enum BorrowError {
    #[display(fmt = "the specified type, key pair doesn't exist in the store")]
    NotFound,
    #[display(fmt = "the queried item is already locked")]
    Locked,
}

impl error::Error for BorrowError {}
//#endregion

//#region store
pub struct Store {
    map: RefCell<TypeMap>,
}

impl Store {
    pub fn new() -> Self {
        Self {
            map: RefCell::new(TypeMap::new()),
        }
    }

    /// start managing an item
    pub fn store<Key, Value>(&self, key: Key, value: Value) -> Result<(), StoreError>
    where
        Key: Copy + Eq + Hash + 'static,
        Value: 'static,
    {
        let mut map = self.map.borrow_mut();
        if !map.contains::<TypeKey<Key, Value>>() {
            map.insert::<TypeKey<Key, Value>>(HashMap::new());
        }

        let hash_map = map.get_mut::<TypeKey<Key, Value>>().unwrap();
        if hash_map.contains_key(&key) {
            Err(StoreError::Existing)?;
        }

        if hash_map.insert(key, State::InStore(Rc::new(value))).is_some() {
            panic!("Internal Error: item should not exist in store")
        };

        Ok(())
    }

    /// get a managed item from store
    pub fn lock<Key, Value>(&self, key: Key) -> Result<Persistent<Key, Value>, LockError>
        where
            Key: Copy + Eq + Hash + 'static,
            Value: 'static,
    {
        let mut map = self.map.borrow_mut();
        let hash_map = match map.get_mut::<TypeKey<Key, Value>>() {
            Some(hash_map) => hash_map,
            None => return Err(LockError::NotFound),
        };
        let value = match hash_map.get_mut(&key) {
            Some(value) => value,
            None => return Err(LockError::NotFound),
        };

        match value {
            State::InStore(value) => {
                if Rc::strong_count(value) != 1 {
                    return Err(LockError::Borrowed);
                }
            },
            State::Locked => return Err(LockError::Locked),
        }

        // Can't just take reference here because that will lock the entire store.
        // Can't use Rc either because the store will hold a reference to it thus prevent us from mutating the object.
        let value = match mem::replace(value, State::Locked) {
            State::InStore(value) => value,
            _ => panic!("Internal Error: value should exist in store"),
        };

        Ok(Persistent{store: self, key, value: Some(Rc::try_unwrap(value).ok().expect("Internal Error: value shouldn't be borrowed"))})
    }

    /// get a reference to a managed item from store
    pub fn borrow<Key, Value>(&self, key: Key) -> Result<PersistentRef<Key, Value>, BorrowError>
    where
        Key: Copy + Eq + Hash + 'static,
        Value: 'static,
    {
        let mut map = self.map.borrow_mut();
        let hash_map = match map.get_mut::<TypeKey<Key, Value>>() {
            Some(hash_map) => hash_map,
            None => return Err(BorrowError::NotFound),
        };
        let value = match hash_map.get_mut(&key) {
            Some(value) => value,
            None => return Err(BorrowError::NotFound),
        };

        let value = match value {
            State::InStore(value) => value.clone(),
            _ => return Err(BorrowError::Locked),
        };

        Ok(PersistentRef{key, value})
    }

    /// return an item to store.
    /// This method should only be called when Persistent<_, _> is dropped.
    /// Thus make it private
    /// @precondition: the value being returned must exist in the store in Locked state. Panic if not met in debug mode.
    fn r#return<Key, Value>(&self, key: Key, value: Value)
    where
        Key: Copy + Eq + Hash + 'static,
        Value: 'static,
    {
        let mut map = self.map.borrow_mut();
        let hash_map = map.get_mut::<TypeKey<Key, Value>>().expect("Internal Error: key should exist in store.");
        let retrived_mark = hash_map.get_mut(&key).expect("Internal Error: key should exist in store.");
        debug_assert_eq!(mem::discriminant(retrived_mark), mem::discriminant(&State::Locked));

        mem::replace(retrived_mark, State::InStore(Rc::new(value)));
    }
}

impl Default for Store {
    fn default() -> Self {
        Self::new()
    }
}
//#endregion