use bevy::{prelude::*, sprite::collide_aabb::collide, asset::LoadState};

use crate::{SIZE, map::TileCollider, TILESIZE, TILEDIST, Animator, Animations, AnimationTimer};

pub struct BoxPlugin;

#[derive(Bundle)]
struct PlayerBundle {
    #[bundle]
    sprite_bundle: SpriteSheetBundle,
    player: Player,
    animator: Animator,
    animations: Animations,
}

impl Plugin for BoxPlugin {
    fn build(&self, app: &mut App) {
        app
            .add_state(AppState::Setup)
            .add_system_set(
                SystemSet::on_enter(AppState::Setup)
                    .with_system(resource_gen)
            )
            .add_system_set(
                SystemSet::on_update(AppState::Setup)
                    .with_system(check_textures)
            )
            .add_system_set(
                SystemSet::on_enter(AppState::Finished)
                    .with_system(texture_loading)
            )
            .add_system_set(
                SystemSet::on_update(AppState::Finished)
                    .with_system(move_box)
                    .with_system(change_texture_atlas)
            );
            // .add_startup_system(spawn_box);
            // .add_startup_system(spawn_box)
            // .add_system(move_box);
            // .add_system(camera_follow);
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
enum AppState {
    Setup,
    Finished,
}


#[derive(Component, Reflect, Default)]
#[reflect(Component)]
pub struct Player {
    speed: f32,
    is_moving: bool,
    idle: Handle<TextureAtlas>,
    run: Handle<TextureAtlas>,
    direction: f32,
}
#[derive(Resource, Default)]
pub struct PlayerAssets {
    pub idle: Vec<HandleUntyped>,
    pub run: Vec<HandleUntyped>,
}

//Generate PlayerAsset
fn resource_gen(mut commands: Commands, asset_server: Res<AssetServer>) {
    let mut plr_assets = PlayerAssets::default();
    plr_assets.idle = asset_server.load_folder("dungeon_sprites/frames/skeleton/idle").unwrap();
    plr_assets.run = asset_server.load_folder("dungeon_sprites/frames/skeleton/run").unwrap();
    commands.insert_resource(plr_assets);
    println!("GameAssets Loaded");
}

fn check_textures(
    mut state: ResMut<State<AppState>>,
    game_assets: ResMut<PlayerAssets>,
    asset_server: Res<AssetServer>,
) {
    if let LoadState::Loaded = asset_server
        .get_group_load_state(
            game_assets.idle.iter().map( |handle| handle.id )
        )
    {
        state.set(AppState::Finished).unwrap();
    }
}

fn create_texture(
    sprites: Vec<HandleUntyped>,
    asset_server: &Res<AssetServer>,
    texture_atlases: &mut ResMut<Assets<TextureAtlas>>,
    mut textures: &mut ResMut<Assets<Image>>
) -> Handle<TextureAtlas> {
    let mut texture_atlas_builder = TextureAtlasBuilder::default();
    for handle in &sprites {
        let handle = handle.typed_weak();
        let Some(texture) = textures.get(&handle) else {
            warn!("{:?} did not resolve to an `Image` asset.", asset_server.get_handle_path(handle));
            continue;
        };
        texture_atlas_builder.add_texture(handle, texture);
    }
    let texture_atlas = texture_atlas_builder.finish(&mut textures).unwrap();
    let texture_atlas_handle = texture_atlases.add(texture_atlas);
    texture_atlas_handle
}

fn texture_loading(
    mut commands: Commands,
    plr_assets: Res<PlayerAssets>,
    asset_server: Res<AssetServer>,
    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
    mut textures: ResMut<Assets<Image>>,
) {
    let run = create_texture(plr_assets.run.clone(), &asset_server, &mut texture_atlases, &mut textures);
    let idle = create_texture(plr_assets.idle.clone(), &asset_server, &mut texture_atlases, &mut textures);
    //  let animation1 =
     // let plr_bundle = PlayerBundle {
    //     player: Player { speed: 3. * 100., is_moving: false, direction: 1. },
    //     sprite_bundle: SpriteSheetBundle {
    //         texture_atlas: idle.clone(),
    //         transform: Transform {
    //             translation: Vec3::new(0.0, 0.0, 2.0),
    //             scale: Vec3::splat(SIZE),
    //             ..default()
    //         },
    //         ..default()
    //     },
    //     animator: Animator {
    //         animations: Animations {
    //             idle: 0..4,
    //             run: 0..6,
    //         },
    //         current_animation: 0..4,
    //         current_frame: 0,
    //         timer: Timer::from_seconds(0.1, TimerMode::Repeating),
    //     },
    //     animations: Animations {
    //
    //
    //     },
    // }
    commands.spawn((SpriteSheetBundle {
        texture_atlas: idle.clone(),
        transform: Transform {
            translation: Vec3::new(0.0, 0.0, 2.0),
            scale: Vec3::splat(SIZE),
            ..default()
        },
        ..default()
        },
        AnimationTimer(Timer::from_seconds(0.1, TimerMode::Repeating)),
    ))
    .insert(Name::new("Player"))
    .insert(Player {
            speed: 3. * 100.,
            is_moving: false,
            idle,
            run,
            direction: 1.,
        });
}



fn change_texture_atlas(
    mut player: Query<(&mut Handle<TextureAtlas>, &Player), With<Player>>,
)
{
    for (mut texture_atlas, player) in &mut player {
        if player.is_moving {
            *texture_atlas = player.run.clone();
        } else {
            *texture_atlas = player.idle.clone();
        }
    }
}
fn change_direciton(
    mut player: Query<(&mut Transform, &Player), With<Player>>,
)
{
    for (mut transform, player) in &mut player {
        if player.direction == -1. {
            //Change scale
            transform.scale = Vec3::new(-1. * SIZE, SIZE, SIZE);
        } else {
            //Change scale
            transform.scale = Vec3::new(SIZE, SIZE, SIZE);
        }
    }
}

fn move_box(
    keyboard_input: Res<Input<KeyCode>>,
    mut query: Query<(&mut Transform, &mut Player),With<Player>>,
    collider_query: Query<&Transform, (With<TileCollider>, Without<Player>)>,
    time: Res<Time>
) {
    let mut change_x: f32 = 0.0;
    let mut change_y: f32 = 0.0;
    let (mut transform, mut square) = query.single_mut(); //As long as there is one player this should work. If there's another player include networking and rollback
    let velocity = square.speed * time.delta_seconds();
    if keyboard_input.pressed(KeyCode::Left) || keyboard_input.pressed(KeyCode::Right) || keyboard_input.pressed(KeyCode::Up) || keyboard_input.pressed(KeyCode::Down) {
       square.is_moving = true;
    }
    else {
        square.is_moving = false;
    }
    if keyboard_input.pressed(KeyCode::Left) {
         change_x -= velocity;

    }
    if keyboard_input.pressed(KeyCode::Right) {
        change_x += velocity;
    }
    if keyboard_input.pressed(KeyCode::Up) {
        change_y += velocity;
    }
    if keyboard_input.pressed(KeyCode::Down) {
        change_y -= velocity;
    }
    let target = transform.translation + Vec3::new(change_x,0.,0.);
    if !collider_query.iter().any(|&transform| wall_collision_check(target, transform.translation)) {
        transform.translation = target;
    }
    let target = transform.translation + Vec3::new(0., change_y, 0.);
    if !collider_query.iter().any(|&transform| wall_collision_check(target, transform.translation)) {
        transform.translation = target;
    }
}

fn wall_collision_check(
    target_player_pos: Vec3,
    wall_translation: Vec3,
)-> bool
{
        let collision = collide(
            target_player_pos,
            Vec2::splat(TILEDIST * 0.8),
            wall_translation,
            Vec2::splat(TILEDIST)
        );
        collision.is_some()
}

fn camera_follow(
    player: Query<&Transform, With<Player>>,
    mut camera: Query<&mut Transform, (Without<Player>, With<Camera>)>,
) {
    let player_transform = player.single();
    let mut camera_transform = camera.single_mut();
    camera_transform.translation.x = player_transform.translation.x;
    camera_transform.translation.y = player_transform.translation.y;
}