use crate::{debug, game_setup};
use bevy::prelude::*;
use bevy_rapier2d::prelude::*;

pub fn init(app: &mut App) {
    let app = app.add_plugins((
        game_setup::GameSetupPlugin,
        RapierPhysicsPlugin::<NoUserData>::default(),
        debug::DebugPlugin,
    ));

    app.add_systems(Startup, setup_2d)
        .add_systems(Update, demo_2d);

    // app.add_systems(Startup, setup_3d)
    //     .add_systems(Update, demo_3d);
}

fn setup_2d(mut commands: Commands) {
    commands.spawn((
        Name::from("Demo 2D camera"),
        Camera2d,
        Transform::from_xyz(0.0, 0.0, 10.0),
    ));
    commands.spawn((
        Name::from("Demo 2D sprite"),
        Sprite::sized(Vec2::splat(256.0)),
    ));
}

fn demo_2d(
    mut camera_query: Query<(&mut Transform, &mut OrthographicProjection)>,
    mut mouse_events: EventReader<bevy::input::mouse::MouseMotion>,
    mut scroll_events: EventReader<bevy::input::mouse::MouseWheel>,
    mouse_input: Res<ButtonInput<MouseButton>>,
) {
    let raw_mouse_motion: Vec2 = mouse_events.read().map(|e| e.delta).sum();
    let raw_scroll_motion: f32 = scroll_events
        .read()
        .map(|event| match event.unit {
            bevy::input::mouse::MouseScrollUnit::Line => event.y * -0.1,
            bevy::input::mouse::MouseScrollUnit::Pixel => event.y * -0.05,
        })
        .sum();

    for (mut transform, mut projection) in camera_query.iter_mut() {
        projection.scale += raw_scroll_motion * projection.scale;
        let mouse_motion = raw_mouse_motion * projection.scale * Vec2::new(-1.0, 1.0);
        if mouse_input.pressed(MouseButton::Middle) {
            transform.translation += mouse_motion.extend(0.0);
        }
    }
}

fn setup_3d(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands.spawn((
        Name::from("Demo 3D camera"),
        Camera3d::default(),
        Transform::from_xyz(0.0, 0.0, 10.0),
        PointLight::default(),
    ));
    commands.spawn((
        Name::from("Demo 3D cuboid"),
        Mesh3d(meshes.add(Cuboid::from_length(1.0))),
        MeshMaterial3d(materials.add(Color::from(bevy::color::palettes::css::ORANGE))),
    ));
}

fn demo_3d(
    mut camera_query: Query<&mut Transform, With<Camera3d>>,
    mut mouse_events: EventReader<bevy::input::mouse::MouseMotion>,
    mouse_input: Res<ButtonInput<MouseButton>>,
    key_input: Res<ButtonInput<KeyCode>>,
    time: Res<Time>,
) {
    let raw_mouse_motion: Vec2 = mouse_events.read().map(|e| e.delta).sum();

    if mouse_input.pressed(MouseButton::Right) {
        let move_forward = key_input.pressed(KeyCode::KeyW);
        let move_back = key_input.pressed(KeyCode::KeyS);
        let move_left = key_input.pressed(KeyCode::KeyA);
        let move_right = key_input.pressed(KeyCode::KeyD);
        let move_up = key_input.pressed(KeyCode::Space) || key_input.pressed(KeyCode::KeyE);
        let move_down = key_input.pressed(KeyCode::ControlLeft) || key_input.pressed(KeyCode::KeyQ);

        let raw_movement = Vec3 {
            x: match (move_right, move_left) {
                (true, false) => 1.0,
                (false, true) => -1.0,
                _ => 0.0,
            },
            y: match (move_up, move_down) {
                (true, false) => 1.0,
                (false, true) => -1.0,
                _ => 0.0,
            },
            z: match (move_back, move_forward) {
                (true, false) => 1.0,
                (false, true) => -1.0,
                _ => 0.0,
            },
        };

        for mut transform in camera_query.iter_mut() {
            let mouse_motion = raw_mouse_motion * Vec2::new(-1.0, -1.0) * 0.002;
            transform.rotate_axis(Dir3::Y, mouse_motion.x);
            transform.rotate_local_x(mouse_motion.y);

            let local_movement = raw_movement * time.delta_secs() * 10.0;
            let movement = transform.rotation * local_movement;
            transform.translation += movement;
        }
    }
}