//! IndexTreeMap is an odered tree map based on the rust standard library BTreeMap,
//! that allows for items to be accessed by key, value, or position in the tree.
//!
//! This library is meant to serve niche use cases where the deterministic
//! ordering of key-value items is required, with the ability to index items
//! by position or key in logarithmic time.

pub mod methods;
pub mod stc;

pub const ARRAY_SIZE: usize = 6;

use stc::{Item, Node};
/// The structures library of the IndexTreeMap
use std::cmp::Ordering;
use std::fmt;
use std::fmt::Debug;
use std::hash::Hash;
use std::str::FromStr;

pub trait Key:
    Send
    + Sync
    + ToString
    + FromStr
    + fmt::Debug
    + fmt::Display
    + Default
    + Clone
    + Unpin
    + Eq
    + Ord
    + Hash
    + fmt::Display
    + 'static // + Copy
// + DerefMut
// + Binary
// + AsRef<[u8]>
// + From<String>
{
    fn new(self) -> Self;
    fn compare_keys(&self, key: &Self) -> Ordering {
        self.cmp(key)
    }
}

impl Key for String {
    fn new(self) -> Self {
        self
    }
}

impl Key for usize {
    fn new(self) -> Self {
        self
    }
}

impl Key for i8 {
    fn new(self) -> Self {
        self
    }
}

impl Key for i16 {
    fn new(self) -> Self {
        self
    }
}

impl Key for i32 {
    fn new(self) -> Self {
        self
    }
}

impl Key for i64 {
    fn new(self) -> Self {
        self
    }
}

impl Key for i128 {
    fn new(self) -> Self {
        self
    }
}

impl Key for u8 {
    fn new(self) -> Self {
        self
    }
}

impl Key for u16 {
    fn new(self) -> Self {
        self
    }
}

impl Key for u32 {
    fn new(self) -> Self {
        self
    }
}

impl Key for u64 {
    fn new(self) -> Self {
        self
    }
}

impl Key for u128 {
    fn new(self) -> Self {
        self
    }
}

// impl Key for f32 {
//     fn new(self) -> Self {self}
// }

// impl Key for f64 {
//     fn new(self) -> Self {self}
// }

impl Key for char {
    fn new(self) -> Self {
        self
    }
}

impl Key for bool {
    fn new(self) -> Self {
        self
    }
}

pub trait Value:
    Send
    + Sync
    + ToString
    + fmt::Debug
    + fmt::Display
    + Default
    + Clone
    + Unpin
    + Eq
    + Ord
    + Hash
    + fmt::Display
    + 'static // + Copy
// + DerefMut
// + Binary
// + AsRef<[u8]>
// + From<String>
{
    fn new(self) -> Self;
    // fn from_bytes(bytes: &[u8]) -> Self;
}

impl Value for String {
    fn new(self) -> Self {
        self
    }
}

impl Value for usize {
    fn new(self) -> Self {
        self
    }
}

impl Value for i8 {
    fn new(self) -> Self {
        self
    }
}

impl Value for i16 {
    fn new(self) -> Self {
        self
    }
}

impl Value for i32 {
    fn new(self) -> Self {
        self
    }
}

impl Value for i64 {
    fn new(self) -> Self {
        self
    }
}

impl Value for i128 {
    fn new(self) -> Self {
        self
    }
}

impl Value for u8 {
    fn new(self) -> Self {
        self
    }
}

impl Value for u16 {
    fn new(self) -> Self {
        self
    }
}

impl Value for u32 {
    fn new(self) -> Self {
        self
    }
}

impl Value for u64 {
    fn new(self) -> Self {
        self
    }
}

impl Value for u128 {
    fn new(self) -> Self {
        self
    }
}

impl Value for char {
    fn new(self) -> Self {
        self
    }
}

impl Value for bool {
    fn new(self) -> Self {
        self
    }
}

#[derive(Debug, Clone)]
pub enum Side {
    Left,
    Right,
}

#[derive(Debug, Clone, Default)]
pub struct IndexTreeMap<K, V> {
    pub root: Box<Node<K, V>>,
    pub size: usize,
}

impl<K: Key, V: Value> fmt::Display for IndexTreeMap<K, V> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        for index in 0..self.size {
            let item = self.get_key_value_from_index(index);
            writeln!(f, "{}, {}", item.0.unwrap(), item.1.unwrap())?
        }
        Ok(())
    }
}

impl<K: Key, V: Value> IndexTreeMap<K, V> {
    /// Makes a new, empty IndexTreeMap.
    ///
    /// Does not allocate anything on its own.
    ///
    /// # Example
    ///
    /// Basic usage:
    /// ```rust
    /// use indextreemap::IndexTreeMap;
    ///
    /// let mut map = IndexTreeMap::new();
    ///
    /// map.insert(1, "a".to_string());
    /// ```    
    pub fn new() -> IndexTreeMap<K, V> {
        IndexTreeMap::default()
    }

    /// Clears the map, removing all elements.
    ///
    /// Does not allocate anything on its own.
    ///
    /// # Example
    ///
    /// Basic usage:
    /// ```rust
    /// use indextreemap::IndexTreeMap;
    ///
    /// let mut map = IndexTreeMap::new();
    ///
    /// map.insert(1, "a".to_string());
    /// map.clear();
    /// assert!(map.is_empty());
    /// ```
    pub fn clear(&mut self) {
        self.root = Node::new();
        self.size = 0
    }

    /// Clears the map, removing all elements.
    ///
    /// # Example
    ///
    /// Basic usage:
    /// ```rust
    /// use indextreemap::IndexTreeMap;
    ///
    /// let mut map = IndexTreeMap::new();
    ///
    /// map.insert(1, "a".to_string());
    /// assert_eq!(map.len(), 1);
    /// ```
    pub fn len(&self) -> usize {
        self.size
    }

    /// Returns true if the map contains no elements.
    ///
    /// # Example
    ///
    /// Basic usage:
    /// ```rust
    /// use indextreemap::IndexTreeMap;
    ///
    /// let mut map = IndexTreeMap::new();
    /// assert!(map.is_empty());
    /// map.insert(1, "a".to_string());
    /// assert!(!map.is_empty());
    /// ```
    pub fn is_empty(&self) -> bool {
        self.size == 0
    }
}