use std::collections::binary_heap::Iter;
use std::collections::HashMap;
use std::iter::Map;
use std::sync::{Arc, Mutex};
use ciborium::Value as CborValue;
use tracing::{instrument, trace};
use colored::Colorize;

use crate::id::MizeId;
use crate::instance::store::{Store, IdIter};
use crate::error::{MizeError, MizeResult, IntoMizeResult};
use crate::item::{Item, ItemData};
use crate::instance::Instance;
use crate::item::get_raw_from_cbor;

#[derive(Clone, Debug)]
pub struct MemStore {
    inner: Arc<Mutex<MemStoreInner>>,
}

pub type MemStoreId = u64;

#[derive(Debug)]
struct MemStoreInner {
    map: HashMap<u64, ItemData>,
    next_id: u64,
}

impl Store for MemStore {
    fn set(&self, id: MizeId, data: ItemData) -> MizeResult<()> {
        let mut inner = self.inner.lock()?;

        inner.map.insert(id_to_u64(id)?, data);
        return Ok(())
    }
    fn get_links(&self, item: Item) -> MizeResult<Vec<MizeId>> {
        let inner = self.inner.lock()?;

        Ok(Vec::new())
    }
    fn get_backlinks(&self, item: Item) -> MizeResult<Vec<MizeId>> {
        let inner = self.inner.lock()?;

        Ok(Vec::new())
    }
    fn new_id(&self) -> MizeResult<String> {
        let mut inner = self.inner.lock()?;

        let id_string = format!("{}", inner.next_id);
        inner.next_id += 1;
        return Ok(id_string);
    }

    #[instrument(name="fn.MemStore::get_value_raw" skip(self))]
    fn get_value_raw(&self, id: MizeId) -> MizeResult<Vec<u8>> {
    trace!("[ {} ] id: {:?}", "ARG".yellow(), id);
        let inner = self.inner.lock()?;

        let cbor_val = inner.map.get(&id_to_u64(id.clone())?)
            .ok_or(MizeError::new()
            .msg(format!("Item with store_part: {}, id: {} does not exist in MemStore", id_to_u64(id.clone())?, id)))?;

        let path = id.path();
        let mut id_iter = path.iter();
        id_iter.next();
        let id_without_first = id_iter.collect();

        Ok(get_raw_from_cbor(&cbor_val.0, id_without_first)?.to_owned())
    }

    fn get_value_data_full(&self, id: MizeId) -> MizeResult<ItemData> {
        let inner = self.inner.lock()?;

        let data = match inner.map.get(&id_to_u64(id.clone())?) {
            Some(val) => val.to_owned(),
            None => ItemData::new(),
        };

        let tmp = id.path();
        let mut path_iter = tmp.into_iter();
        path_iter.next();
        let new_path: Vec<String> = path_iter.map(|v| v.to_owned()).collect();
        let ret_data = data.get_path(new_path)?;

        return Ok(ret_data);
    }
    fn id_iter(&self) -> MizeResult<IdIter> {

        IdIter::new(Box::new(self.to_owned()))
    }

    fn next_id(&self, prev_id_str: &str) -> MizeResult<Option<String>> {
        let inner = self.inner.lock()?;

        let mut id = str_to_u64(prev_id_str)?;

        loop {

            id += 1;

            if id > inner.next_id {
                return Ok(None);
            }

            if inner.map.contains_key(&id) {
                println!("returning: {}", id);
                return Ok(Some(format!("{}", id)));

            } else {
                // try id +1
                continue;
            }
        }
    }

    fn first_id(&self) -> MizeResult<String> {
        Ok("0".to_owned())
    }
}

impl MemStore {
    pub fn new() -> MemStore {
        let inner = MemStoreInner { map: HashMap::new(), next_id: 0 };
        return MemStore { inner: Arc::new(Mutex::new(inner)) };
    }
}

fn id_to_u64(id: MizeId) -> MizeResult<u64> {
    str_to_u64(id.store_part())
}

fn str_to_u64(id_str: &str) -> MizeResult<u64> {
    id_str.parse()
        .mize_result_msg(format!("Could not parse the store_part of mizeid {} into a u64 for the MemStore", id_str))
}