use std::collections::{HashMap, VecDeque};
use std::hash::Hash;
use std::ops::AddAssign;

#[derive(Clone, Default, Debug)]
pub struct ValuePair<T: AddAssign + Default + Clone> {
    first: T,
    second: T,
}

impl<T: AddAssign + Default + Clone> ValuePair<T> {
    pub fn new(first: T, second: T) -> Self {
        ValuePair { first, second }
    }
}

impl<T: AddAssign + Default + Clone> AddAssign for ValuePair<T> {
    fn add_assign(&mut self, other: Self) {
        self.first += other.first;
        self.second += other.second;
    }
}

#[derive(Clone, Default, Debug)]
pub struct LimitedSizeMap<K, V>
where
    K: Eq + Hash + Clone,
    V: AddAssign + Default + Clone,
{
    max_size: usize,
    keys_order: VecDeque<K>,
    map: HashMap<K, V>,
}

impl<K, T> LimitedSizeMap<K, ValuePair<T>>
where
    K: Eq + Hash + Clone,
    T: AddAssign + Default + Clone + From<u32>,
{
    pub fn new(max_size: usize) -> Self {
        LimitedSizeMap {
            max_size,
            keys_order: VecDeque::new(),
            map: HashMap::new(),
        }
    }

    pub fn add(&mut self, key: K, increment1: T, increment2: T) {
        if !self.map.contains_key(&key) && self.map.len() == self.max_size {
            if let Some(oldest_key) = self.keys_order.pop_front() {
                self.map.remove(&oldest_key);
            }
        }

        let entry = self
            .map
            .entry(key.clone())
            .or_insert_with(|| ValuePair::default());

        entry.first += increment1;
        entry.second += increment2;

        if !self.keys_order.contains(&key) {
            self.keys_order.push_back(key);
        }
    }
}