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

use winit::event::ElementState;

pub struct CachedElementState<K: Eq + Hash> {
    cache: HashMap<K, ElementState>,
}

impl<K: Eq + Hash> Default for CachedElementState<K> {
    fn default() -> Self {
        Self {
            cache: HashMap::new(),
        }
    }
}

impl<K: Eq + Hash> CachedElementState<K> {
    pub fn set_key_state(&mut self, key: K, state: ElementState) -> Option<ElementState> {
        let key_state = self.cache.get(&key);
        let new_key_state = match key_state {
            Some(old) => match state {
                ElementState::Pressed => match old {
                    ElementState::Released => Some(ElementState::Pressed),
                    ElementState::Pressed => None,
                },
                ElementState::Released => match old {
                    ElementState::Released => None,
                    ElementState::Pressed => Some(ElementState::Released),
                },
            },
            None => match state {
                ElementState::Pressed => Some(ElementState::Pressed),
                ElementState::Released => Some(ElementState::Released),
            },
        };
        if let Some(new_key_state) = new_key_state {
            self.cache.insert(key, new_key_state);
        }
        new_key_state
    }
}

#[derive(Default)]
pub struct CachedMovement<T>
where
    T: Sub<Output = T> + Add<Output = T> + Default + Copy,
{
    pub old_value: Option<T>,
    pub value: T,
}

impl<T> CachedMovement<T>
where
    T: Sub<Output = T> + Add<Output = T> + Default + Copy,
{
    pub fn set_value(&mut self, value: T) {
        self.value = value;
    }

    pub fn reset(&mut self) -> T {
        match self.old_value.as_ref() {
            Some(old_value) => {
                let diff = self.value - *old_value;
                self.old_value = Some(self.value);
                diff
            }
            None => {
                self.old_value = Some(self.value);
                T::default()
            }
        }
    }
}

impl<T> AddAssign<T> for CachedMovement<T>
where
    T: Add<Output = T> + Sub<Output = T> + Default + Copy,
{
    fn add_assign(&mut self, rhs: T) {
        self.value = self.value + rhs;
    }
}