//! Map entries.
//!
//! The API is similar to that of `BTreeMap` and `HashMap`'s `Entry` types.
use super::*;

/// Varient of [`Entry`](Entry) that already contains a value.
#[derive(Debug)]
pub struct OccupiedEntry<'a, K, V>(pub(crate) &'a mut Option<(K,V)>);

impl<'a, K, V> OccupiedEntry<'a, K, V>
where K: Collapse
{
    /// Get a reference to the value
    pub fn get(&self) -> &V
    {
	&self.0.as_ref().unwrap().1
    }
    /// Get a mutable reference to the value
    pub fn get_mut(&mut self) -> &mut V
    {
	&mut self.0.as_mut().unwrap().1
    }
    /// Consume this instance, returning the held mutable reference to the value
    pub fn into_mut(self) -> &'a mut V
    {
	&mut self.0.as_mut().unwrap().1
    }
    /// A reference to the key
    pub fn key(&self) -> &K
    {
	&self.0.as_ref().unwrap().0
    }
    /// Replace the held value with another, yielding the old one
    pub fn insert(&mut self, value: V) -> V
    {
	core::mem::replace(&mut self.0.as_mut().unwrap().1, value)
    }
    /// Remove this entry from the `Map`, yielding the removed value
    pub fn remove(self) -> V
    {
	self.remove_entry().1
    }
    /// Remove this entry from the `Map`, yielding the removed key-value pair.
    pub fn remove_entry(self) -> (K, V)
    {
	self.0.take().unwrap()
    }
}

/// Varient of [`Entry`](Entry) that does not contain a value.
#[derive(Debug)]
pub struct VacantEntry<'a,K,V>(pub(crate) &'a mut Option<(K,V)>, pub(crate) K);

impl<'a, K, V> VacantEntry<'a, K, V>
where K: Collapse
{
    /// Insert a value into this empty slot, retuning a mutable reference to the new value.
    pub fn insert(self, value: V) -> &'a mut V
    {
	*self.0 = Some((self.1, value));
	&mut self.0.as_mut().unwrap().1
    }

    /// Consume this instance, returning the held key.
    pub fn into_key(self) -> K
    {
	self.1
    }

    /// A reference to the held key
    pub fn key(&self) -> &K
    {
	&self.1
    }
}

/// Represents a space in a `Map` that may or may not contains a value.
#[derive(Debug)]
pub enum Entry<'a, K, V>
{
    /// This entry slot does not yet contain a value
    Vacant(VacantEntry<'a, K, V>),
    /// This entry slot does contain a value
    Occupied(OccupiedEntry<'a, K, V>),
}

impl<'a, K, V> Entry<'a, K, V>
where K: Collapse
{
    /// Run this closure on a mutable reference to the internal value if it is present, otherwise do nothing.
    pub fn and_modify<F: FnOnce(&mut V)>(mut self, f: F) -> Entry<'a, K, V>
    {
	if let Self::Occupied(occuped) = &mut self {
	    f(occuped.get_mut())
	}
	self
    }
    
    /// A reference to the key
    pub fn key(&self) -> &K
    {
	match self {
	    Entry::Vacant(v) => v.key(),
	    Entry::Occupied(o) => o.key(),
	}
    }

    /// Insert into the entry if it is empty the value returned by the closure and return a mutable reference to the new value, otherwise return a mutable reference to the already present value.
    pub fn or_insert_with<F: FnOnce() -> V>(self, with: F) -> &'a mut V
    {
	match self {
	    Entry::Occupied(o) => o.into_mut(),
	    Entry::Vacant(v) => v.insert(with())
	}
    }

    /// Insert into the entry this value if it is empty and return a mutable reference to the new value, otherwise return a mutable reference to the already present value.
    #[inline] pub fn or_insert(self, value: V) -> &'a mut V
    {
	self.or_insert_with(|| value)
    }

}

impl<'a, K, V> Entry<'a, K, V>
where K: Collapse,
      V: Default
{
    /// Insert into the entry the default value if it is empty and return a mutable reference to the new value, otherwise return a mutable reference to the already present value.
    #[inline] pub fn or_default(self) -> &'a mut V
    {
	self.or_insert_with(Default::default)
    }
}