use bevy::prelude::*;
use heron::prelude::*;

use crate::{geometry::CyberBike, input::InputState};

/// Mouse sensitivity and movement speed
pub struct MovementSettings {
    pub sensitivity: f32,
    pub accel: f32,
    pub drag: f32,
    pub gravity: f32,
}

impl Default for MovementSettings {
    fn default() -> Self {
        Self {
            sensitivity: 1.0,
            accel: 40.,
            drag: 0.0005,
            gravity: 10.0,
        }
    }
}

#[derive(Component, Default)]
pub(crate) struct CyberBikeState {
    pub velocity: Vec3,
    pub colliding: bool,
}

fn falling_cat(time: Res<Time>, mut bike_query: Query<&mut Transform, With<CyberBike>>) {
    let dt = time.delta_seconds();

    let mut bike_xform = bike_query.single_mut();
    let up = bike_xform.translation.normalize();
    let cam_up = bike_xform.up();
    let cos = up.dot(cam_up);

    let theta = cos.acos();
    let rate = if !theta.is_normal() {
        0.0
    } else if theta.is_sign_negative() {
        -0.4
    } else {
        0.4
    } * dt;
    let angle = if rate.is_sign_negative() {
        rate.max(theta)
    } else {
        rate.min(theta)
    };

    let rot = Quat::from_axis_angle(cam_up.cross(up).normalize(), angle);

    if rot.is_finite() && theta.abs() > 1.0f32.to_radians() {
        bike_xform.rotate(rot);
    }
}

fn update_velocity(
    time: Res<Time>,
    settings: Res<MovementSettings>,
    input: Res<InputState>,
    mut query: Query<(&Transform, &mut CyberBikeState)>,
) {
    let dt = time.delta_seconds();
    let (xform, mut state) = query.single_mut();

    // first gravity
    let down = -xform.translation.normalize();
    let dvel = down * settings.gravity * dt;
    let mut vel = if state.velocity.is_finite() {
        state.velocity + dvel
    } else {
        dvel
    };

    // thrust or brake
    vel += xform.forward() * input.throttle * dt * settings.accel;

    // brake
    if input.brake {
        let s = vel.length_squared();
        if s < 0.05 {
            vel = Vec3::ZERO;
        } else {
            vel -= vel.normalize() * settings.accel * dt;
        }
    }

    // drag
    let v2 = vel.length_squared().min(100_000.0);
    let drag = vel * settings.drag * v2 * dt;
    vel -= drag;

    if vel.length_squared() < 0.0001 {
        vel = Vec3::ZERO;
    }

    state.velocity = vel;
}

fn apply_velocity(time: Res<Time>, mut bike_query: Query<(&mut Transform, &CyberBikeState)>) {
    let dt = time.delta_seconds();

    let (mut bike_xform, state) = bike_query.single_mut();

    if state.velocity.is_finite() {
        bike_xform.translation += state.velocity * dt;
    }
}

fn steer_cyberbike(
    settings: Res<MovementSettings>,
    windows: Res<Windows>,
    time: Res<Time>,
    istate: Res<InputState>,
    mut query: Query<&mut Transform, With<CyberBike>>,
) {
    let window = windows.get_primary().unwrap();
    let window_scale = window.height().min(window.width());
    let dt = time.delta_seconds();
    let mut transform = query.single_mut();

    let d_yaw = (settings.sensitivity * dt * window_scale * istate.yaw).to_radians();
    let rotation = Quat::from_axis_angle(transform.local_y(), d_yaw);

    transform.rotate(rotation);
}

fn collisions(
    mut events: EventReader<CollisionEvent>,
    mut query: Query<(&Transform, &mut CyberBikeState)>,
) {
    let (xform, mut state) = query.single_mut();

    for event in events.iter() {
        if let CollisionEvent::Started(_, _) = event {
            state.colliding = true;
        } else {
            state.colliding = false;
        }
    }

    // now see if we're currently colliding
    if state.colliding {
        let down = -xform.translation.normalize();
        let vel = state.velocity;
        let dvel = down * vel.dot(down) * 1.0001;
        state.velocity -= dvel;
    }
}

pub struct CyberPhysicsPlugin;
impl Plugin for CyberPhysicsPlugin {
    fn build(&self, app: &mut App) {
        app.init_resource::<CyberBikeState>()
            .init_resource::<MovementSettings>()
            .add_plugin(PhysicsPlugin::default())
            .add_system(collisions)
            .add_system(falling_cat)
            .add_system(update_velocity)
            .add_system(steer_cyberbike)
            .add_system(apply_velocity);
    }
}