use bevy::{prelude::*, sprite::MaterialMesh2dBundle};

use bevy::prelude::*;
// use bevy::sprite::MaterialMesh2dBundle;
use bevy_asset_loader::prelude::*;

use iyes_progress::prelude::*;

            .init_state::<GameState>()

            // TODO Make sure update_movement_pointer is ran after all systems that
            // can affect MovementDirection

            // Mark Loading as a loading state, and progress to InGame once done
            .add_plugins(ProgressPlugin::new(GameState::Loading).continue_to(GameState::InGame))
            .add_loading_state(
                LoadingState::new(GameState::Loading).load_collection::<PlayerAssets>(),
            )

                ),

                )
                    .run_if(in_state(GameState::InGame)),

            .add_systems(FixedUpdate, (move_player, update_camera));

            .add_systems(
                FixedUpdate,
                (move_player, update_camera).run_if(in_state(GameState::InGame)),
            );

// fn test_move_pointer(time: Res<Time>, mut directed: Query<&mut MovementDirection>) {
//     for mut md in directed.iter_mut() {
//         let angle = Vec2::from_angle(std::f32::consts::FRAC_PI_2 * time.delta_seconds());
//         md.0 = angle.rotate(md.0);
//     }
// }
/// The highest speed something is capable of moving

#[derive(Clone, PartialEq, Eq, Debug, Hash, Default, States)]
enum GameState {
    #[default]
    Loading,
    InGame,
}
#[derive(AssetCollection, Resource)]
struct PlayerAssets {
    #[asset(path = "dum_player.png")]
    texture: Handle<Image>,
    #[asset(texture_atlas_layout(tile_size_x = 32., tile_size_y = 48., columns = 4, rows = 8))]
    layout: Handle<TextureAtlasLayout>,
}

            Option<&mut Sprite>,

    for (action_state, mut transform, dash, mut md) in query.iter_mut() {

    for (action_state, mut transform, maybe_sprite, dash, mut md) in query.iter_mut() {

                // If we have a sprite, flip x if we moved in a negative x dir
                if let Some(mut sprite) = maybe_sprite {
                    sprite.flip_x = movement_norm.x.signum() == -1.0;
                }

    mesh: MaterialMesh2dBundle<ColorMaterial>,

    // mesh: MaterialMesh2dBundle<ColorMaterial>,
    sprite_sheet: SpriteSheetBundle,

    mut meshes: ResMut<Assets<Mesh>>,

    // mut meshes: ResMut<Assets<Mesh>>,

    player_assets: Res<PlayerAssets>,

            mesh: MaterialMesh2dBundle {
                mesh: meshes
                    .add(Rectangle {
                        half_size: (16.0, 16.0).into(),
                    })
                    .into(),
                // Be careful not to overwrite the LDtk transform
                transform: *transform,
                material: materials.add(Color::PURPLE),

            sprite_sheet: SpriteSheetBundle {
                texture: player_assets.texture.clone(),
                atlas: TextureAtlas {
                    layout: player_assets.layout.clone(),
                    index: 0,
                },
                transform: (*transform) * Transform::default().with_translation(Vec3::Y * 8.0),

            // mesh: MaterialMesh2dBundle {
            //     mesh: meshes
            //         .add(Rectangle {
            //             half_size: (16.0, 24.0).into(),
            //         })
            //         .into(),
            //     // Be careful not to overwrite the LDtk transform
            //     // Change our origin
            //     transform: (*transform) * Transform::default().with_translation(Vec3::Y * 8.0),
            //     material: materials.add(Color::PURPLE),
            //     ..default()
            // },

                // Fake depth by scaling y translation
                let faked_norm = norm * Vec2::new(1.0, 0.85);

                transform.translation = (norm

                transform.translation = (faked_norm