use bevy::{
    prelude::{
        info, Commands, Component, Entity, Input, KeyCode, ParamSet, PerspectiveCameraBundle,
        PerspectiveProjection, Plugin, Quat, Query, Res, ResMut, State, Transform, With,
    },
    render::camera::{ActiveCamera, Camera3d},
};

use crate::{bike::CyberBikeModel, input::InputState};

// 85 degrees in radians
const MAX_PITCH: f32 = 1.48353;

#[derive(Clone, Copy, Eq, PartialEq, Debug, Hash, Component)]
enum CyberCameras {
    Hero,
    Debug,
}

impl CyberCameras {
    fn next(self) -> Self {
        match self {
            CyberCameras::Debug => CyberCameras::Hero,
            CyberCameras::Hero => CyberCameras::Debug,
        }
    }
}

fn setup_cybercams(mut commands: Commands) {
    let hero_projection = PerspectiveProjection {
        fov: std::f32::consts::FRAC_PI_3,
        ..Default::default()
    };
    commands
        .spawn_bundle(PerspectiveCameraBundle {
            perspective_projection: hero_projection,
            ..Default::default()
        })
        .insert(CyberCameras::Hero);

    commands
        .spawn_bundle(PerspectiveCameraBundle::default())
        .insert(CyberCameras::Debug);
}

fn follow_cyberbike(
    mut query: ParamSet<(
        // 0: the bike
        Query<&Transform, With<CyberBikeModel>>,
        // 1: the cameras
        Query<(&mut Transform, &CyberCameras)>,
    )>,
    input: Res<InputState>,
) {
    let bike_xform = *query.p0().single();
    let up = bike_xform.translation.normalize();

    for (mut cam_xform, cam_type) in query.p1().iter_mut() {
        match *cam_type {
            CyberCameras::Hero => {
                let look_at = bike_xform.translation + (bike_xform.forward() * 200.0);
                let cam_pos = bike_xform.translation + (bike_xform.back() * 2.7) + (up * 2.4);

                cam_xform.translation = cam_pos;
                cam_xform.look_at(look_at, up);

                // handle input pitch
                let angle = input.pitch.powi(3) * MAX_PITCH;
                let axis = cam_xform.right();
                cam_xform.rotate(Quat::from_axis_angle(axis, angle));
            }
            CyberCameras::Debug => {
                let pos = bike_xform.translation
                    + (bike_xform.forward() * 10.0)
                    + (bike_xform.left() * 30.0)
                    + (bike_xform.up() * 7.0);
                cam_xform.translation = pos;
                cam_xform.look_at(bike_xform.translation, up);
            }
        }
    }
}

fn update_active_camera(
    mut active_cams: ResMut<ActiveCamera<Camera3d>>,
    state: Res<State<CyberCameras>>,
    mut query: Query<(&CyberCameras, Entity)>,
) {
    // find the camera with the current state, set it as the ActiveCamera
    query
        .iter_mut()
        .filter(|(cybercam, _)| state.current().eq(cybercam))
        .for_each(|(_, entity)| {
            active_cams.set(entity);
        });
}

fn cycle_cam_state(mut state: ResMut<State<CyberCameras>>, mut keys: ResMut<Input<KeyCode>>) {
    if keys.just_pressed(KeyCode::D) {
        let new_state = state.current().next();
        info!("{:?}", new_state);
        state.set(new_state).unwrap();
        keys.reset(KeyCode::D);
    }
}

pub struct CyberCamPlugin;
impl Plugin for CyberCamPlugin {
    fn build(&self, app: &mut bevy::prelude::App) {
        app.add_startup_system(setup_cybercams)
            .add_state(CyberCameras::Hero)
            .add_system(cycle_cam_state)
            .add_system(update_active_camera)
            .add_system(follow_cyberbike);
    }
}