use ecs::time::Time;

use crate::builder;
use crate::camera::{Active as ActiveCamera, Camera, Controllable as ControllableCamera};
use crate::ecs::actions::Actions;
use crate::ecs::component::local::Local;
use crate::ecs::phase::UPDATE as UPDATE_PHASE;
use crate::ecs::query::term::With;
use crate::ecs::sole::Single;
use crate::ecs::system::initializable::Initializable;
use crate::ecs::system::Into;
use crate::ecs::{Component, Query};
use crate::input::keyboard::{Key, Keyboard};
use crate::input::mouse::Mouse;
use crate::reflection::Reflection;
use crate::transform::WorldPosition;
use crate::vector::{Vec2, Vec3};

builder! {
/// A fly camera.
#[builder(name = Builder, derives = (Debug))]
#[derive(Debug, Component, Reflection)]
#[non_exhaustive]
pub struct Fly {
    pub current_pitch: f64,
    pub current_yaw: f64,
    pub speed: f32,
}
}

impl Fly
{
    #[must_use]
    pub fn builder() -> Builder
    {
        Builder::default()
    }
}

impl Default for Fly
{
    fn default() -> Self
    {
        Self::builder().build()
    }
}

impl Default for Builder
{
    fn default() -> Self
    {
        Self {
            current_yaw: -90.0,
            current_pitch: 0.0,
            speed: 3.0,
        }
    }
}

/// Fly camera extension.
pub struct Extension(pub Options);

impl crate::ecs::extension::Extension for Extension
{
    fn collect(self, mut collector: crate::ecs::extension::Collector<'_>)
    {
        collector.add_system(*UPDATE_PHASE, update.into_system().initialize((self.0,)));
    }
}

#[derive(Debug, Component)]
pub struct Options
{
    pub mouse_sensitivity: f32,
}

fn update(
    camera_query: Query<
        (
            &mut Camera,
            &mut WorldPosition,
            &mut Fly,
            Option<&ControllableCamera>,
        ),
        (With<ActiveCamera>,),
    >,
    keyboard: Single<Keyboard>,
    mouse: Single<Mouse>,
    time: Single<Time>,
    options: Local<Options>,
    mut actions: Actions,
) -> Result<(), crate::Error>
{
    let keyboard = keyboard.get()?;
    let mouse = mouse.get()?;

    for (
        camera_ent_id,
        (mut camera, mut camera_world_pos, mut fly_camera, controllable_camera),
    ) in camera_query.iter_with_euids()
    {
        if let Some(controllable_camera) = controllable_camera {
            if !controllable_camera.control_enabled {
                continue;
            }
        } else {
            actions.add_components(camera_ent_id, (ControllableCamera::default(),));
        }

        if mouse.curr_tick_position_delta != (Vec2 { x: 0.0, y: 0.0 }) {
            let x_offset =
                mouse.curr_tick_position_delta.x * f64::from(options.mouse_sensitivity);

            let y_offset = (-mouse.curr_tick_position_delta.y)
                * f64::from(options.mouse_sensitivity);

            fly_camera.current_yaw += x_offset;
            fly_camera.current_pitch += y_offset;

            fly_camera.current_pitch = fly_camera.current_pitch.clamp(-89.0, 89.0);
        }

        // TODO: This casting to a f32 from a f64 is horrible. fix it
        #[allow(clippy::cast_possible_truncation)]
        let direction = Vec3 {
            x: (fly_camera.current_yaw.to_radians().cos()
                * fly_camera.current_pitch.to_radians().cos()) as f32,
            y: fly_camera.current_pitch.to_radians().sin() as f32,
            z: (fly_camera.current_yaw.to_radians().sin()
                * fly_camera.current_pitch.to_radians().cos()) as f32,
        }
        .normalize();

        let cam_right = direction.cross(&Vec3::UP).normalize();

        camera.global_up = cam_right.cross(&direction).normalize();

        if keyboard.pressed(Key::W) {
            camera_world_pos.position +=
                direction * fly_camera.speed * time.delta_time.as_secs_f32();
        }

        if keyboard.pressed(Key::S) {
            camera_world_pos.position -=
                direction * fly_camera.speed * time.delta_time.as_secs_f32();
        }

        if keyboard.pressed(Key::A) {
            let cam_left = -direction.cross(&Vec3::UP).normalize();

            camera_world_pos.position +=
                cam_left * fly_camera.speed * time.delta_time.as_secs_f32();
        }

        if keyboard.pressed(Key::D) {
            let cam_right = direction.cross(&Vec3::UP).normalize();

            camera_world_pos.position +=
                cam_right * fly_camera.speed * time.delta_time.as_secs_f32();
        }

        camera.target = camera_world_pos.position + direction;
    }

    Ok(())
}