use std::{collections::VecDeque, fmt::Debug, time::Duration};

use crossterm::event::KeyCode;
use gilrs::{
	Axis, Button, GamepadId, Gilrs, PowerInfo,
	ff::{BaseEffect, Replay, Ticks},
};
use rustc_hash::{FxHashMap, FxHashSet};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Direction {
	Up = 1,
	Down,
	Left,
	Right,
}

#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Position {
	pub x: u16,
	pub y: u16,
}

#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
struct ControllerButton {
	gamepad_id: usize,
	button: Button,
}

#[derive(Debug)]
pub struct InputManager {
	pressed_keys: FxHashSet<KeyCode>,
	mouse_clicked: bool,
	mouse_location: Option<Position>,
	scroll_direction: Option<Direction>,
	is_focused: bool,
	is_focused_this_frame: bool,
	is_unfocused_this_frame: bool,
	gil_cx: Option<Gilrs>,
	gamepad_map: FxHashMap<usize, GamepadId>,
	gamepad_map_rev: FxHashMap<GamepadId, usize>,
	connected_gamepads: VecDeque<usize>,
	pressed_buttons: FxHashSet<ControllerButton>,
	released_buttons: FxHashSet<ControllerButton>,
}

impl InputManager {
	pub fn new() -> Self {
		Self {
			pressed_keys: FxHashSet::default(),
			mouse_clicked: false,
			mouse_location: None,
			scroll_direction: None,
			is_focused: true,
			is_focused_this_frame: false,
			is_unfocused_this_frame: false,
			gil_cx: Gilrs::new().ok(),
			gamepad_map: FxHashMap::default(),
			gamepad_map_rev: FxHashMap::default(),
			connected_gamepads: VecDeque::new(),
			pressed_buttons: FxHashSet::default(),
			released_buttons: FxHashSet::default(),
		}
	}

	pub fn press_key(&mut self, key_code: KeyCode) {
		self.pressed_keys.insert(key_code);
	}

	pub fn click_mouse(&mut self) {
		self.mouse_clicked = true;
	}

	pub fn move_mouse(&mut self, location: Position) {
		self.mouse_location = Some(location);
	}

	pub fn scroll(&mut self, direction: Direction) {
		self.scroll_direction = Some(direction);
	}

	pub fn reset_next_frame(&mut self) {
		puffin::profile_function!();
		self.pressed_keys.clear();
		self.mouse_clicked = false;
		self.scroll_direction = None;
		self.is_focused_this_frame = false;
		self.is_unfocused_this_frame = false;
		self.pressed_buttons.clear();
		self.released_buttons.clear();
		self.connected_gamepads.pop_front();
	}

	pub fn is_key_pressed_this_frame(&self, key_code: KeyCode) -> bool {
		self.pressed_keys.contains(&key_code)
	}

	pub fn is_mouse_clicked_this_frame(&self) -> bool {
		self.mouse_clicked
	}

	pub fn mouse_location(&self) -> Option<Position> {
		self.mouse_location
	}

	pub fn scroll_direction_this_frame(&self) -> Option<Direction> {
		self.scroll_direction
	}

	pub fn read_gil_events(&mut self) {
		let Some(gil) = self.gil_cx.as_mut() else {
			return;
		};
		while let Some(event) = gil.next_event() {
			let gamepad_id = self.gamepad_map_rev.get(&event.id).copied();
			match event.event {
				gilrs::EventType::Connected => {
					let gamepad_id = self.gamepad_map.len() + 1;
					self.gamepad_map.insert(gamepad_id, event.id);
					self.gamepad_map_rev.insert(event.id, gamepad_id);
					self.connected_gamepads.push_back(gamepad_id);
				}
				gilrs::EventType::ButtonPressed(button, _) => {
					let Some(gamepad_id) = gamepad_id else {
						continue;
					};
					self.pressed_buttons
						.insert(ControllerButton { gamepad_id, button });
				}
				gilrs::EventType::ButtonReleased(button, _) => {
					let Some(gamepad_id) = gamepad_id else {
						continue;
					};
					self.released_buttons
						.insert(ControllerButton { gamepad_id, button });
				}
				_ => {}
			}
		}
	}

	pub fn is_gamepad_connected_this_frame(&self) -> Option<usize> {
		self.connected_gamepads.front().copied()
	}

	pub fn is_button_pressed_this_frame(&self, gamepad_id: usize, button: Button) -> bool {
		self.pressed_buttons
			.contains(&ControllerButton { gamepad_id, button })
	}

	pub fn is_button_released_this_frame(&self, gamepad_id: usize, button: Button) -> bool {
		self.released_buttons
			.contains(&ControllerButton { gamepad_id, button })
	}

	pub fn is_button_down(&self, gamepad_id: usize, button: Button) -> bool {
		self.gamepad_map.get(&gamepad_id).is_some_and(|id| {
			self.gil_cx
				.as_ref()
				.is_some_and(|gil| gil.gamepad(*id).is_pressed(button))
		})
	}

	pub fn axis_value(&self, gamepad_id: usize, axis: Axis) -> Option<f32> {
		self.gamepad_map
			.get(&gamepad_id)
			.and_then(|id| self.gil_cx.as_ref().map(|gil| gil.gamepad(*id).value(axis)))
	}

	pub fn is_gamepad_connected(&self, gamepad_id: usize) -> bool {
		self.gamepad_map.get(&gamepad_id).is_some_and(|id| {
			self.gil_cx
				.as_ref()
				.is_some_and(|gil| gil.gamepad(*id).is_connected())
		})
	}

	pub fn gamepad_power_info(&self, gamepad_id: usize) -> Option<PowerInfo> {
		self.gamepad_map.get(&gamepad_id).and_then(|id| {
			self.gil_cx
				.as_ref()
				.map(|gil| gil.gamepad(*id).power_info())
		})
	}

	pub fn vibrate(&mut self, gamepad_id: usize, intensity: f32, duration: Duration) {
		let Some(gamepad_id) = self.gamepad_map.get(&gamepad_id) else {
			return;
		};
		let Some(gil) = self.gil_cx.as_mut() else {
			return;
		};
		let gamepad = gil.gamepad(*gamepad_id);
		let Ok(effect) = gilrs::ff::EffectBuilder::new()
			.add_gamepad(&gamepad)
			.add_effect(BaseEffect {
				kind: gilrs::ff::BaseEffectType::Strong {
					magnitude: (intensity * u16::MAX as f32).round() as u16,
				},
				scheduling: Replay {
					after: Ticks::from_ms(0),
					play_for: Ticks::from_ms(duration.as_millis() as u32),
					with_delay: Ticks::from_ms(0),
				},
				envelope: todo!(),
			})
			.repeat(gilrs::ff::Repeat::For(Ticks::from_ms(
				duration.as_millis() as u32
			)))
			.finish(gil)
		else {
			return;
		};
		_ = effect.play();
	}

	pub fn focus(&mut self) {
		self.is_focused = true;
		self.is_focused_this_frame = true;
	}

	pub fn unfocus(&mut self) {
		self.is_focused = false;
		self.is_unfocused_this_frame = true;
	}

	pub fn is_focused(&self) -> bool {
		self.is_focused
	}

	pub fn was_focused_this_frame(&self) -> bool {
		self.is_focused_this_frame
	}

	pub fn was_unfocused_this_frame(&self) -> bool {
		self.is_unfocused_this_frame
	}
}

impl Default for InputManager {
	fn default() -> Self {
		Self::new()
	}
}