use bevy::{
    input::mouse::AccumulatedMouseMotion, prelude::*, render::view::RenderLayers, window::{PrimaryWindow, WindowResized}
};
use bevy_rapier3d::prelude::*;

pub mod toolbar;

use crate::{asset_loading::FlashlightAssets, GameState};

#[derive(Debug, Component, Default)]
pub struct Player {
    pub speed_factor: f32,
}

#[derive(Debug, Component, Deref, DerefMut)]
pub struct CameraSensitivity(Vec2);
impl Default for CameraSensitivity {
    fn default() -> Self {
        Self(Vec2::new(0.003, 0.002))
    }
}

#[derive(Debug, Component)]
pub struct WorldModelCamera;

#[derive(Debug, Component, Default)]
pub struct PlayerInput {
    movement_direction: Vec3,
}

#[derive(Component, Debug)]
pub struct HeadBob {
    pub enabled: bool,
    pub intensity: f32,
    pub speed: f32,
    pub time_offset: f32,
}

impl Default for HeadBob {
    fn default() -> Self {
        Self {
            enabled: true,
            intensity: 0.05,
            speed: 10.0,
            time_offset: 0.0,
        }
    }
}

#[derive(Component, Debug)]
pub struct BaseTransform(pub Transform);

pub fn plugin(app: &mut App) {
    app.add_plugins(toolbar::plugin)
        .add_systems(OnEnter(GameState::Playing), (init_player, hide_cursor))
        .add_systems(
            Update,
            (move_camera, handle_input, apply_head_bob, on_resize_system).run_if(in_state(GameState::Playing)),
        )
        .add_systems(
            FixedUpdate,
            apply_player_movement.run_if(in_state(GameState::Playing)),
        );
}

// used by the view model camera and the player's arm.
const STATIC_LAYER: usize = 1;

pub fn init_player(
    mut commands: Commands,
    flashlights: Res<FlashlightAssets>,
    window: Query<&Window>,
) {
    commands
        .spawn((
            Player::default(),
            PlayerAction::default(),
            CameraSensitivity::default(),
            PlayerInput::default(),
            toolbar::Item::none(),
            HeadBob::default(),
            // rapier
            RigidBody::Dynamic,
            Collider::capsule(Vec3::new(0.0, -0.5, 0.0), Vec3::new(0.0, 0.5, 0.0), 0.5),
            Velocity::zero(),
            LockedAxes::ROTATION_LOCKED,
            Damping {
                linear_damping: 6.0,
                angular_damping: 1.0,
            },
            GravityScale(3.0),
            Transform::from_xyz(0.0, 0.5, 0.0),
        ))
        .with_children(|parent| {
            parent.spawn((
                WorldModelCamera,
                Camera3d::default(),
                Projection::from(PerspectiveProjection {
                    fov: 90.0_f32.to_radians(),
                    ..default()
                }),
            ));

            // camera voor pitslampke
            parent.spawn((
                Camera2d::default(),
                Camera {
                    order: 1,
                    ..default()
                },
                RenderLayers::layer(STATIC_LAYER),
            ));
            
            let window = window.single();
            let transform = flashlight_base_transform(window.width(), window.height());
            parent.spawn((
                Sprite::from_image(flashlights.flash_hold_4.clone()),
                transform.0.clone(),
                transform,
                RenderLayers::layer(STATIC_LAYER),
            ));
        });
}

fn on_resize_system(
    mut resize_reader: EventReader<WindowResized>,
    mut sprites: Query<(&mut Transform, &mut BaseTransform), With<Sprite>>,
) {
    for e in resize_reader.read() {
        for (mut transform, mut base_transform) in sprites.iter_mut() {
            let new_pos = flashlight_base_transform(e.width, e.height);
            *transform = new_pos.0.clone();
            *base_transform = new_pos;
        }
    }
}

fn flashlight_base_transform(window_width: f32, window_height: f32) -> BaseTransform {
    let window_size = Vec2::new(window_width, window_height);
    let sprite_size = Vec2::new(101.0, 101.0); 
    let scale = window_width / 600.0;
    let world_size = sprite_size * scale;
    let xoffset = window_size.x / 4.0 - 40.0;
    let yoffset = 15.0;
    
    let mut transform = Transform::from_translation(
        Vec3::new(window_size.x / 2.0 - world_size.x / 2.0 - xoffset, -window_size.y / 2.0 + world_size.y / 2.0 - yoffset, 0.0)
    );
    transform.scale = Vec3::new(scale, scale, 1.0);
    return BaseTransform(transform);
}

fn hide_cursor(mut windows: Query<&mut Window, With<PrimaryWindow>>) {
    for mut window in windows.iter_mut() {
        window.cursor_options.visible = false;
    }
}

const PITCH_LIMIT: f32 = std::f32::consts::FRAC_PI_2 - 0.01;

pub fn move_camera(
    accumulated_mouse_motion: Res<AccumulatedMouseMotion>,
    mut player: Query<(&mut Transform, &CameraSensitivity), With<Player>>,
) {
    let Ok((mut transform, camera_sensitivity)) = player.get_single_mut() else {
        return;
    };
    let delta = accumulated_mouse_motion.delta;

    if delta != Vec2::ZERO {
        let delta_yaw = -delta.x * camera_sensitivity.x;
        let delta_pitch = -delta.y * camera_sensitivity.y;

        let (yaw, pitch, roll) = transform.rotation.to_euler(EulerRot::YXZ);
        let yaw = yaw + delta_yaw;
        let pitch = (pitch + delta_pitch).clamp(-PITCH_LIMIT, PITCH_LIMIT);
        transform.rotation = Quat::from_euler(EulerRot::YXZ, yaw, pitch, roll);
    }
}

#[derive(Component, Debug, Clone, Copy, Eq, PartialEq, Hash, Reflect, Default)]
pub(crate) enum PlayerAction {
    #[default]
    Move,
    Sprint,
    Jump,
    Interact,
    ToggleFlashlight
}

pub fn handle_input(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut query: Query<(&Transform, &mut PlayerInput, &mut PlayerAction, &mut Player), With<Player>>,
) {
    for (transform, mut input, mut action, mut player) in query.iter_mut() {
        let forward = transform.forward();
        let right = transform.right();
        let mut movement_direction = Vec3::ZERO;

        if keyboard_input.pressed(KeyCode::KeyW) {
            movement_direction += Vec3::new(forward.x, 0.0, forward.z).normalize_or_zero();
        }
        if keyboard_input.pressed(KeyCode::KeyS) {
            movement_direction -= Vec3::new(forward.x, 0.0, forward.z).normalize_or_zero();
        }
        if keyboard_input.pressed(KeyCode::KeyA) {
            movement_direction -= Vec3::new(right.x, 0.0, right.z).normalize_or_zero();
        }
        if keyboard_input.pressed(KeyCode::KeyD) {
            movement_direction += Vec3::new(right.x, 0.0, right.z).normalize_or_zero();
        }
        if keyboard_input.pressed(KeyCode::Space) {
            movement_direction += Vec3::Y;
        }
        if keyboard_input.pressed(KeyCode::ShiftLeft) {
            player.speed_factor = 1.35;
            *action = PlayerAction::Sprint
        } else if keyboard_input.pressed(KeyCode::ControlLeft) {
            player.speed_factor = 0.65;
        } else {
            player.speed_factor = 1.0; 
        }
        if keyboard_input.pressed(KeyCode::KeyE) {
            *action = PlayerAction::Interact
        }
        if keyboard_input.pressed(KeyCode::KeyA) {
            *action = PlayerAction::ToggleFlashlight;
        }

        input.movement_direction = movement_direction.normalize_or_zero();
    }
}

pub fn apply_player_movement(mut player_query: Query<(&PlayerInput, &mut Velocity, &Player), With<Player>>) {
    const SPEED: f32 = 2.6;
    const JUMP_FORCE: f32 = 4.0;

    for (input, mut velocity, player) in player_query.iter_mut() {
        let speed = SPEED * player.speed_factor;
        let horizontal_movement = Vec3::new(
            input.movement_direction.x * speed,
            0.0,
            input.movement_direction.z * speed,
        );

        velocity.linvel.x = horizontal_movement.x;
        velocity.linvel.z = horizontal_movement.z;

        if input.movement_direction.y > 0.0 {
            velocity.linvel.y = JUMP_FORCE;
        } 
    }
}

pub fn apply_head_bob(
    time: Res<Time>,
    mut query: Query<(&PlayerInput, &mut HeadBob, &Player), With<Player>>,
    mut camera_query: Query<&mut Transform, (With<WorldModelCamera>, Without<Player>)>,
    mut sprite_query: Query<(&mut Transform, &Sprite, &BaseTransform), (With<Sprite>, Without<WorldModelCamera>, Without<Player>)>,
) {
    let Ok((input, mut head_bob, player)) = query.get_single_mut() else {
        return;
    };

    // bob when moving horizontally
    let horizontal_movement = Vec3::new(input.movement_direction.x, 0.0, input.movement_direction.z);
    let is_moving = horizontal_movement.length_squared() > 0.01;
    let bobbing_speed = head_bob.speed * player.speed_factor;

    let mut offset = bobbing_speed * time.delta_secs();
    if !is_moving {
        // decrease bobbing frequency when stationary
        offset *= 0.2;

        // bob returns to neutral position when stopped
        if let Some(camera_transform) = camera_query.iter_mut().next() {
            let current_offset = camera_transform.translation.y;
            if current_offset.abs() < 0.005 {
                // cancel out so head_bob.time_offset 
                offset = -head_bob.time_offset;
            }
        }
    }
    head_bob.time_offset += offset;

    if head_bob.enabled {
        // calculate vertical and horizontal offsets using sine and cosine
        let vertical_offset = head_bob.intensity * f32::sin(head_bob.time_offset);
        let horizontal_offset = (head_bob.intensity * 0.5) * f32::cos(head_bob.time_offset * 0.5);
        
        // apply
        for mut transform in camera_query.iter_mut() {
            transform.translation.y = vertical_offset;
            if is_moving {
                transform.translation.x = horizontal_offset;
            } else {
                // decrease bobbing magnitued
                transform.translation.x *= 0.8;
            }
        }
        
        // apply offsets to flashlight
        for (mut transform, _sprite, base_transform) in sprite_query.iter_mut() {
            let scale_factor = 40.0 * player.speed_factor;
        
            if is_moving {
                transform.translation.x = base_transform.0.translation.x + horizontal_offset * scale_factor;
                transform.translation.y = base_transform.0.translation.y + vertical_offset * scale_factor;
        
                transform.rotation = Quat::from_euler(
                    EulerRot::XYZ,
                    0.0,
                    0.0,
                    horizontal_offset * 0.1,
                );
            } else {
                transform.translation = transform.translation.lerp(base_transform.0.translation, 0.1);
                transform.rotation = transform.rotation.slerp(Quat::IDENTITY, 0.1);
            }
        }
    }
}