use bevy::prelude::*;
use bevy::input::mouse::MouseMotion;
use bevy::window::PrimaryWindow;
use std::f32::consts::*;
use crate::{settings, audio};

pub struct CameraControllerPlugin;

impl Plugin for CameraControllerPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(Update, run_camera_controller);
    }
}

// Based on Valorant's default sensitivity, not entirely sure why it is exactly 1.0 / 180.0,
// but I'm guessing it is a misunderstanding between degrees/radians and then sticking with
// it because it felt nice.
pub const RADIANS_PER_DOT: f32 = 1.0 / 180.0;

#[derive(Component)]
pub struct CameraController {
    pub enabled: bool,
    pub initialized: bool,
    pub sensitivity: f32,
    pub move_speed: f32,
    pub friction: f32,
    pub pitch: f32,
    pub yaw: f32,
    pub velocity: Vec3,
}

impl Default for CameraController {
    fn default() -> Self {
        Self {
            enabled: true,
            initialized: false,
            sensitivity: 0.5,
            move_speed: 1.0,
            friction: 0.1,
            pitch: 1.0, // pitch=0/yaw=0 -> face sun
            yaw: 0.3,
            velocity: Vec3::ZERO,
        }
    }
}

#[allow(clippy::too_many_arguments)]
fn run_camera_controller(
    time: Res<Time>,
    settings: Res<settings::Settings>,
    mut windows: Query<&mut Window, With<PrimaryWindow>>,
    mut mouse_events: EventReader<MouseMotion>,
    key_input: Res<ButtonInput<KeyCode>>,
    thruster_sound_controller: Query<&AudioSink, With<audio::ComponentThrusterSound>>,
    mut query: Query<(&mut Transform, &mut CameraController), With<Camera>>,
) {
    let dt = time.delta_seconds();
    let mut play_thruster_sound = false;

    let window_result = windows.get_single_mut();
    let mut focused = true;
    if window_result.is_ok() {
        focused = window_result.unwrap().focused;
    }

    if let Ok((mut transform, mut controller)) = query.get_single_mut() {
        if !controller.initialized {
            controller.initialized = true;
            transform.rotation =
                Quat::from_euler(EulerRot::ZYX, 0.0, controller.yaw, controller.pitch);
        }
        if !controller.enabled {
            mouse_events.clear();
            return;
        }

        // Handle key input
        let mut axis_input = Vec3::ZERO;
        if focused {
            if key_input.pressed(settings.key_forward) {
                axis_input.z += 1.0;
            }
            if key_input.pressed(settings.key_back) {
                axis_input.z -= 1.0;
            }
            if key_input.pressed(settings.key_right) {
                axis_input.x += 1.0;
            }
            if key_input.pressed(settings.key_left) {
                axis_input.x -= 1.0;
            }
            if key_input.pressed(settings.key_up) {
                axis_input.y += 1.0;
            }
            if key_input.pressed(settings.key_down) {
                axis_input.y -= 1.0;
            }
        }

        let friction = if key_input.pressed(settings.key_stop) {
            controller.friction.clamp(0.0, 1.0)
        } else {
            0.0
        };

        // Apply movement update
        if axis_input != Vec3::ZERO {
            let new_velocity = controller.velocity + axis_input.normalize() * controller.move_speed;
            controller.velocity = new_velocity;
            play_thruster_sound = !settings.mute_sfx;
        } else {
            controller.velocity *= 1.0 - friction;
            if controller.velocity.length_squared() < 1e-6 {
                controller.velocity = Vec3::ZERO;
            }
        }
        let forward = *transform.forward();
        let right = *transform.right();
        transform.translation += controller.velocity.x * dt * right
            + controller.velocity.y * dt * Vec3::Y
            + controller.velocity.z * dt * forward;

        // Handle mouse input
        let mut mouse_delta = Vec2::ZERO;
        for mouse_event in mouse_events.read() {
            mouse_delta += mouse_event.delta;
        }

        if mouse_delta != Vec2::ZERO {
            // Apply look update
            controller.pitch = (controller.pitch
                - mouse_delta.y * RADIANS_PER_DOT * controller.sensitivity)
                .clamp(-PI / 2., PI / 2.);
            controller.yaw -= mouse_delta.x * RADIANS_PER_DOT * controller.sensitivity;
            transform.rotation =
                Quat::from_euler(EulerRot::ZYX, 0.0, controller.yaw, controller.pitch);
        }

        if let Ok(sink) = thruster_sound_controller.get_single() {
            if play_thruster_sound {
                sink.play()
            } else {
                sink.pause()
            }
        }
    }
}