use std::collections::HashMap;

use crate::item::Item;

/*
pub trait Backend {
    type Key;

    type IterKeys:
    type IterItems:
    type IterItemsMut:

    fn contains_key(&self, key: Self::Key) -> bool;
    fn insert(&mut self, key: Self::Key, item: Item);
    fn get_id(&self, key: Self::Key) -> usize;
    fn get_item(&mut self, id: usize) -> &mut Item;
    fn item(&self, id: usize) -> &Item;
    fn item_mut(&mut self, id: usize) -> &mut Item;
    fn items(&self) -> impl Iterator<Item = &Item>;
    fn items_mut(&mut self) -> impl Iterator<Item = &mut Item>;
    fn keys(&self) -> impl Iterator<Item = &String>;
}
*/

#[derive(Default)]
pub struct Storage {
    keys: HashMap<String, usize>,
    items: Vec<Item>,
}

impl Storage {
    pub fn contains_key(&self, key: &str) -> bool {
        self.keys.contains_key(key)
    }

    pub fn insert(&mut self, key: String, item: Item) {
        let index = self.items.len();

        self.items.push(item);
        self.keys.insert(key, index);
    }

    pub fn get_id(&self, key: &str) -> usize {
        self.keys[key]
    }

    pub fn get_item(&mut self, id: usize) -> &mut Item {
        &mut self.items[id]
    }

    pub fn item(&self, id: usize) -> &Item {
        &self.items[id]
    }

    pub fn item_mut(&mut self, id: usize) -> &mut Item {
        &mut self.items[id]
    }

    pub fn items(&self) -> impl Iterator<Item = &Item> {
        self.items.iter()
    }

    pub fn items_mut(&mut self) -> impl Iterator<Item = &mut Item> {
        self.items.iter_mut()
    }

    pub fn keys(&self) -> impl Iterator<Item = &String> {
        self.keys.keys()
    }
}