use std::collections::HashMap;

use ecs::Sole;

use crate::vector::Vec2;

#[derive(Debug, Default, Clone, Sole)]
#[non_exhaustive]
pub struct Motion
{
    pub position_delta: Vec2<f64>,
}

/// Mouse buttons.
#[derive(Debug, Default, Sole)]
pub struct Buttons
{
    map: HashMap<Button, ButtonData>,
}

impl Buttons
{
    pub fn get(&self, button: Button) -> ButtonState
    {
        let Some(button_data) = self.map.get(&button) else {
            return ButtonState::Released;
        };

        button_data.current_state
    }

    pub fn get_previous(&self, button: Button) -> ButtonState
    {
        let Some(button_data) = self.map.get(&button) else {
            return ButtonState::Released;
        };

        button_data.previous_state
    }

    pub fn set(&mut self, button: Button, button_state: ButtonState)
    {
        let button_data = self.map.entry(button).or_default();

        button_data.current_state = button_state;
    }

    pub(crate) fn make_states_previous(&mut self)
    {
        for button_data in self.map.values_mut() {
            button_data.previous_state = button_data.current_state;
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Button
{
    Left,
    Right,
    Middle,
    Back,
    Forward,
    Other(u16),
}

impl From<winit::event::MouseButton> for Button
{
    fn from(mouse_button: winit::event::MouseButton) -> Self
    {
        match mouse_button {
            winit::event::MouseButton::Left => Self::Left,
            winit::event::MouseButton::Right => Self::Right,
            winit::event::MouseButton::Middle => Self::Middle,
            winit::event::MouseButton::Back => Self::Back,
            winit::event::MouseButton::Forward => Self::Forward,
            winit::event::MouseButton::Other(other_mouse_button) => {
                Self::Other(other_mouse_button)
            }
        }
    }
}

/// Mouse button state.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum ButtonState
{
    Pressed,
    Released,
}

impl ButtonState
{
    #[must_use]
    #[inline]
    pub fn is_pressed(&self) -> bool
    {
        matches!(self, Self::Pressed)
    }

    #[must_use]
    #[inline]
    pub fn is_released(&self) -> bool
    {
        matches!(self, Self::Released)
    }
}

impl From<winit::event::ElementState> for ButtonState
{
    fn from(element_state: winit::event::ElementState) -> Self
    {
        match element_state {
            winit::event::ElementState::Pressed => Self::Pressed,
            winit::event::ElementState::Released => Self::Released,
        }
    }
}

#[derive(Debug)]
struct ButtonData
{
    current_state: ButtonState,
    previous_state: ButtonState,
}

impl Default for ButtonData
{
    fn default() -> Self
    {
        Self {
            current_state: ButtonState::Released,
            previous_state: ButtonState::Released,
        }
    }
}