/*
==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--

Binn-IR

Copyright (C) 2018-2023  Anonymous

There are several releases over multiple years,
they are listed as ranges, such as: "2018-2023".

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.

::--::--::--::--::--::--::--::--::--::--::--::--::--::--::--::--
*/

//! # Shortcuts for `Value::Map`

use {
    core::iter::FromIterator,
    crate::{Error, Map, MapKey, Result, Value},
};

/// # Helper macro for Value::*_maybe_by()/*_maybe_mut_by()
macro_rules! maybe_by_or_mut_by { ($self: ident, $variant: tt, $keys: ident, $code: tt) => {{
    if $keys.is_empty() {
        return Err(err!("Keys must not be empty"));
    }

    let mut value = Some($self);
    for (nth, key) in $keys.iter().enumerate() {
        match value {
            Some(Value::$variant(variant)) => value = variant.$code(key),
            Some(_) => return Err(match nth {
                0 => err!("Value is not {}", stringify!($variant)),
                _ => err!("Value at {keys:?} is not {variant}", keys=&$keys[..nth], variant=stringify!($variant)),
            }),
            None => return Err(err!("There is no value at {:?}", &$keys[..nth])),
        };
    }

    Ok(value)
}}}

/// # Helper macro for Value::*_take_by()
macro_rules! maybe_take_by { ($self: ident, $variant: tt, $keys: ident) => {{
    let mut value = Some($self);
    for (nth, key) in $keys.iter().enumerate() {
        match value {
            Some(Value::$variant(variant)) => if nth + 1 == $keys.len() {
                return Ok(variant.remove(key));
            } else {
                value = variant.get_mut(key);
            },
            Some(_) => return Err(match nth {
                0 => err!("Value is not {}", stringify!($variant)),
                _ => err!("Value at {keys:?} is not {variant}", keys=&$keys[..nth], variant=stringify!($variant)),
            }),
            None => return Err(err!("There is no value at {:?}", &$keys[..nth])),
        };
    }

    Err(err!("Keys must not be empty"))
}}}

/// # Shortcuts for [`Map`](#variant.Map)
impl Value {

    /// # If the value is a map, inserts new item into it
    ///
    /// On success, returns previous value (if it existed).
    ///
    /// Returns an error if the value is not a map.
    pub fn map_insert<K, V>(&mut self, key: K, value: V) -> Result<Option<Self>> where K: Into<MapKey>, V: Into<Self> {
        match self {
            Self::Map(map) => Ok(crate::map_insert(map, key, value)),
            _ => Err(err!("Value is not a map")),
        }
    }

    /// # Gets an immutable item from this map and its sub maps
    ///
    /// The function returns an error on one of these conditions:
    ///
    /// - Keys are empty.
    /// - The value or any of its sub items is not a map.
    ///
    /// ## Examples
    ///
    /// ```
    /// let mut map = binn_ir::map();
    /// map.map_insert(0, true)?;
    /// map.map_insert(1, {
    ///     let mut map = binn_ir::Map::new();
    ///     binn_ir::map_insert(&mut map, 2, 99);
    ///     map
    /// })?;
    ///
    /// assert_eq!(bool::try_from(map.map_by(&[0])?)?, true);
    /// assert_eq!(u8::try_from(map.map_by(&[1, 2])?)?, 99);
    ///
    /// assert!(map.map_by(&[2]).is_err());
    /// assert!(map.map_maybe_by(&[2])?.is_none());
    ///
    /// assert!(map.map_by(&[]).is_err());
    /// assert!(map.map_by(&[0, 2]).is_err());
    /// assert!(map.map_by(&[1, 2, 3]).is_err());
    ///
    /// # Ok::<_, binn_ir::Error>(())
    /// ```
    pub fn map_by(&self, keys: &[MapKey]) -> Result<&Self> {
        self.map_maybe_by(keys)?.ok_or_else(|| err!("There is no value at: {:?}", keys))
    }

    /// # Gets an optional immutable item from this map and its sub maps
    ///
    /// The function returns an error on one of these conditions:
    ///
    /// - Keys are empty.
    /// - The value or any of its sub items is not a map.
    pub fn map_maybe_by(&self, keys: &[MapKey]) -> Result<Option<&Self>> {
        maybe_by_or_mut_by!(self, Map, keys, get)
    }

    /// # Gets a mutable item from this map and its sub maps
    ///
    /// The function returns an error on one of these conditions:
    ///
    /// - Keys are empty.
    /// - The value or any of its sub items is not a map.
    pub fn map_mut_by(&mut self, keys: &[MapKey]) -> Result<&mut Self> {
        self.map_maybe_mut_by(keys)?.ok_or_else(|| err!("There is no value at: {:?}", keys))
    }

    /// # Gets an optional mutable item from this map and its sub maps
    ///
    /// The function returns an error on one of these conditions:
    ///
    /// - Keys are empty.
    /// - The value or any of its sub items is not a map.
    pub fn map_maybe_mut_by(&mut self, keys: &[MapKey]) -> Result<Option<&mut Self>> {
        maybe_by_or_mut_by!(self, Map, keys, get_mut)
    }

    /// # Takes an item from this map and its sub maps
    ///
    /// The function returns an error on one of these conditions:
    ///
    /// - Keys are empty.
    /// - The value or any of its sub items is not a map.
    ///
    /// ## Examples
    ///
    /// ```
    /// let mut map = binn_ir::map();
    /// map.map_insert(0, "zero")?;
    /// map.map_insert(1, {
    ///     let mut map = binn_ir::Map::new();
    ///     binn_ir::map_insert(&mut map, 2, "two");
    ///     map
    /// })?;
    ///
    /// assert_eq!(map.map_take_by(&[0])?.as_text()?, "zero");
    /// assert_eq!(map.map_take_by(&[1, 2])?.as_text()?, "two");
    ///
    /// assert!(map.map_take_by(&[0]).is_err());
    /// assert!(map.map_maybe_take_by(&[0])?.is_none());
    /// assert!(map.map_maybe_take_by(&[1, 2])?.is_none());
    ///
    /// assert!(map.map_take_by(&[]).is_err());
    /// assert!(map.map_take_by(&[3, 4]).is_err());
    ///
    /// # Ok::<_, binn_ir::Error>(())
    /// ```
    pub fn map_take_by(&mut self, keys: &[MapKey]) -> Result<Self> {
        self.map_maybe_take_by(keys)?.ok_or_else(|| err!("There is no value at: {:?}", keys))
    }

    /// # Takes an optional item from this map and its sub maps
    ///
    /// The function returns an error on one of these conditions:
    ///
    /// - Keys are empty.
    /// - The value or any of its sub items is not a map.
    pub fn map_maybe_take_by(&mut self, keys: &[MapKey]) -> Result<Option<Self>> {
        maybe_take_by!(self, Map, keys)
    }

    /// # If the value is a map, returns an immutable reference of it
    ///
    /// Returns an error if the value is not a map.
    pub fn as_map(&self) -> Result<&Map> {
        match self {
            Self::Map(map) => Ok(map),
            _ => Err(err!("Value is not a Map")),
        }
    }

    /// # If the value is a map, returns a mutable reference of it
    ///
    /// Returns an error if the value is not a map.
    pub fn as_mut_map(&mut self) -> Result<&mut Map> {
        match self {
            Self::Map(map) => Ok(map),
            _ => Err(err!("Value is not a Map")),
        }
    }

}

impl From<Map> for Value {

    fn from(map: Map) -> Self {
        Self::Map(map)
    }

}

impl FromIterator<(MapKey, Value)> for Value {

    fn from_iter<T>(iter: T) -> Self where T: IntoIterator<Item=(MapKey, Self)> {
        Self::Map(iter.into_iter().collect())
    }

}

impl TryFrom<Value> for Map {

    type Error = Error;

    fn try_from(v: Value) -> core::result::Result<Self, Self::Error> {
        match v {
            Value::Map(map) => Ok(map),
            _ => Err(err!("Value is not a Map")),
        }
    }

}