use winit::event::{MouseButton, MouseScrollDelta, WindowEvent};

use crate::camera::Camera;

const MAX_ZOOM_LEVEL: f32 = 15.0;

pub struct CameraController {
	zoom_speed: f32,
	movement_speed: f32,

	zoom: f32,
	cursor_start: (f32, f32),
	movement: (f32, f32),
	is_moving: bool,

	movement_total: (f32, f32),
	zoom_total: f32,
}

impl CameraController {
	pub fn new(zoom_speed: f32, movement_speed: f32) -> Self {
		Self {
			zoom_speed,
			movement_speed,

			zoom: 0.0,
			cursor_start: (0.0, 0.0),
			movement: (0.0, 0.0),
			is_moving: false,

			movement_total: (0.0, 0.0),
			zoom_total: 1.0,
		}
	}

	pub fn process_events(&mut self, window_size: (f64, f64), event: &WindowEvent) -> bool {
		match event {
			WindowEvent::MouseInput { state, button, .. } => {
				if state.is_pressed() && *button == MouseButton::Left {
					self.is_moving = true;
					return true;
				}
				else {
					self.is_moving = false;
					self.movement = (0.0, 0.0);
				}
				false
			}
			WindowEvent::CursorMoved { position, .. } => {
				if !self.is_moving {
					self.cursor_start = (position.x as f32, position.y as f32);
				}

				self.movement = match self.is_moving {
					true => {
						let x = (-self.cursor_start.0 + position.x as f32) / 1000.0;
						let x = x * self.movement_speed;
						let y = (self.cursor_start.1 - position.y as f32) / 1000.0;
						let y = y * self.movement_speed;
						(x, y)
					}
					false => {
						let x = match position.x {
							x if x < 100.0 => -0.0005,
							x if x > window_size.0 - 100.0 => 0.0005,
							_ => 0.0,
						};

						let y = match position.y {
							y if y < 100.0 => 0.0005,
							y if y > window_size.1 - 100.0 => -0.0005,
							_ => 0.0,
						};

						(x, y)
					}
				};

				true
			}
			WindowEvent::MouseWheel { delta, .. } => match delta {
				MouseScrollDelta::LineDelta(_, y) => {
					self.zoom_total += y;
					if self.zoom_total >= 0.0 && self.zoom_total <= MAX_ZOOM_LEVEL {
						self.zoom = *y;
					}
					self.zoom_total = self.zoom_total.clamp(0.0, MAX_ZOOM_LEVEL);
					true
				}
				_ => false,
			},
			_ => false,
		}
	}

	pub fn update_camera(&mut self, camera: &mut Camera) {
		use cgmath::InnerSpace;

		let forward = camera.target - camera.eye;
		let forward_norm = forward.normalize();

		if self.zoom > 0.0 {
			camera.eye += forward_norm * self.zoom_speed;
		}
		else if self.zoom < 0.0 {
			camera.eye -= forward_norm * self.zoom_speed;
		}

		self.movement_total.0 += self.movement.0;
		self.movement_total.1 += self.movement.1;

		if self.movement_total.0 > -1.0 && self.movement_total.0 < 1.0 {
			camera.eye.x += self.movement.0;
			camera.target.x += self.movement.0;
		}

		if self.movement_total.1 > -1.0 && self.movement_total.1 < 1.0 {
			camera.eye.y += self.movement.1;
			camera.target.y += self.movement.1;
		}

		self.movement_total.0 = self.movement_total.0.clamp(-1.0, 1.0);
		self.movement_total.1 = self.movement_total.1.clamp(-1.0, 1.0);

		self.zoom = 0.0;
	}

	pub fn reset_camera(&mut self, camera: &mut Camera) {
		camera.reset_camera();
		self.zoom_total = 1.0;
	}
}