use std::{any::Any, hash::Hash, time::Duration};

use animation::{run_animations, AnimBundle, Animation};
use bevy::{ecs::system::SystemId, prelude::*, sprite::MaterialMesh2dBundle, utils::HashMap};

use bevy_rapier2d::prelude::*;

use crate::{AppState, METER};

use super::{
    scene::{PlayerCoords, WorldInfo},
    set::IngameSet,
    PLAYER_DEPTH,
};

mod animation;

#[derive(Event)]
enum PlayerDeathEvent {
    Void,
    Spikes,
}
#[derive(Event)]
struct RespawnPointSetEvent;

#[derive(Component)]
struct Player {
    move_cooldown: Timer,
}

impl Default for Player {
    fn default() -> Self {
        Self {
            move_cooldown: Timer::from_seconds(0.01, TimerMode::Repeating),
        }
    }
}

#[derive(Resource)]
pub struct PlayerSpawnOneshot(pub SystemId);

impl FromWorld for PlayerSpawnOneshot {
    fn from_world(world: &mut World) -> Self {
        Self(world.register_system(add_player))
    }
}

pub(super) fn player_plugin(app: &mut App) {
    app.add_systems(
        Update,
        (
            move_player,
            debug_player_pos,
            run_animations::<PlayerAnimations>,
        ),
    )
    .init_resource::<PlayerSpawnOneshot>();
}

#[derive(Component, Hash, PartialEq, Eq, Default)]
enum PlayerAnimations {
    #[default]
    Idle,
    Walk,
}

fn debug_player_pos(query: Query<&Transform, With<Player>>) {
    let trans = query.single();
}
fn move_player(
    mut commands: Commands,
    kb_input: Res<ButtonInput<KeyCode>>,
    mut query: Query<(
        &mut Velocity,
        &mut Transform,
        &mut Player,
        &mut KinematicCharacterController,
        &mut Sprite,
        &mut PlayerAnimations,
    )>,
    mut camera_query: Query<&mut Transform, (With<Camera2d>, Without<Player>)>,
    phys: Query<&KinematicCharacterControllerOutput>,
    player_coords: Res<PlayerCoords>,
    world_info: Res<WorldInfo>,
    time: Res<Time>,
) {
    let (mut vel, mut p_transform, mut player, mut controller, mut sprite, mut anim_state) =
        query.single_mut();
    let (mut cam_transform) = camera_query.single_mut();
    let (output) = phys.get_single();
    if player.move_cooldown.tick(time.delta()).finished() {
        let mut moved = false;
        let mut move_x = 0;
        let mut move_y = 0;
        let mut jump = false;
        let grounded = output.is_ok_and(|x| x.grounded);
        if kb_input.pressed(KeyCode::KeyA) {
            moved = true;
            move_x -= 1;
        }
        if kb_input.pressed(KeyCode::KeyD) {
            moved = true;
            move_x += 1;
        }
        if kb_input.pressed(KeyCode::Space) && vel.linvel.y < 0.1 && grounded {
            moved = true;
            move_y += 1;
        }

        let orig = cam_transform.translation;
        cam_transform.translation -= ((orig - p_transform.translation.xy().extend(0.0)) / 30.0);

        controller.translation = Some(Vec2::new(move_x as f32 * 6., 0. - 0.01));
        vel.linvel += Vec2::new(0., move_y as f32 * 6. * METER);

        if move_x != 0 && grounded {
            *anim_state = PlayerAnimations::Walk;
            sprite.flip_x = move_x == -1;
        } else if move_x == 0 && grounded {
            *anim_state = PlayerAnimations::Idle;
        }

        for p in world_info.spawnpoints.iter().rev() {
            let x = p.0 as f32 * world_info.block_size;
            if x < p_transform.translation.x && x != player_coords.x {
                commands.insert_resource(PlayerCoords {
                    x,
                    y: p.1 as f32 * world_info.block_size,
                    ..*player_coords
                });
                commands.trigger(RespawnPointSetEvent);

                break;
            }
        }

        if p_transform.translation.y < -10. * player_coords.block_size {
            commands.trigger(PlayerDeathEvent::Void);
            p_transform.translation =
                Vec2::new(player_coords.x, player_coords.y).extend(PLAYER_DEPTH);
        }
    }
}

fn add_player(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
    mut texture_atlas_layouts: ResMut<Assets<TextureAtlasLayout>>,
    asset_server: Res<AssetServer>,
    player_coords: Res<PlayerCoords>,
) {
    let tex_idle = asset_server.load("idle.png");
    let layout_idle = TextureAtlasLayout::from_grid(UVec2::splat(512), 2, 1, None, None);
    let layout_idle_handle = texture_atlas_layouts.add(layout_idle);

    let tex_walk = asset_server.load("walk.png");
    let layout_walk = TextureAtlasLayout::from_grid(UVec2::splat(512), 4, 1, None, None);
    let layout_walk_handle = texture_atlas_layouts.add(layout_walk);

    let anims = animation::AnimationManager::default()
        .insert(
            PlayerAnimations::Idle,
            Animation::new(layout_idle_handle.clone(), 2, 4, tex_idle.clone()),
        )
        .insert(
            PlayerAnimations::Walk,
            Animation::new(layout_walk_handle.clone(), 4, 10, tex_walk.clone()),
        );

    commands
        .spawn((
            Player::default(),
            AnimBundle {
                tag: PlayerAnimations::Idle,
                mgr: anims,
            },
            SpriteBundle {
                sprite: Sprite {
                    custom_size: Some(Vec2::splat(1.)),
                    ..Default::default()
                },
                transform: (*player_coords).into(),
                texture: tex_idle,
                ..Default::default()
            },
            TextureAtlas {
                layout: layout_idle_handle,
                index: 0,
            },
        ))
        .insert((
            RigidBody::Dynamic,
            player_coords.get_collider(),
            LockedAxes::ROTATION_LOCKED,
            Velocity::default(),
            AdditionalMassProperties::MassProperties(MassProperties {
                local_center_of_mass: Vec2 { x: 0.5, y: 0.5 },
                mass: 10000.0,
                principal_inertia: 1.,
            }),
        ))
        .insert(KinematicCharacterController {
            //translation: todo!(),
            //custom_shape: todo!(),
            custom_mass: Some(10000.0),
            //up: todo!(),
            offset: CharacterLength::Absolute(0.01),
            slide: true,
            //autostep: Some(CharacterAutostep {
            //    max_height: CharacterLength::Relative(0.1),
            //    min_width: CharacterLength::Absolute(1.0),
            //    include_dynamic_bodies: false,
            //}),
            //max_slope_climb_angle: todo!(),
            //min_slope_slide_angle: todo!(),
            apply_impulse_to_dynamic_bodies: true,
            snap_to_ground: Some(CharacterLength::Absolute(0.5)),
            //filter_flags: todo!(),
            //filter_groups: todo!(),
            // normal_nudge_factor: 1.,
            ..Default::default()
        });
}