use crate::{inspector::HideFromInspector, prelude::*};
// use bevy::{
//     ecs::world::CommandQueue,
//     tasks::{AsyncComputeTaskPool, Task},
// };
// use bevy_ecs_tilemap::prelude::*;
use rand::prelude::*;
use rand_pcg::Pcg64;
use rand_seeder::Seeder;

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

// #[derive(Component)]
// struct MapGen(Task<CommandQueue>);

/// This worked but had performance issues, so I decided to go with bevy_ecs_tilemap
pub fn spawn_raw_tiles(mut commands: Commands, assets: Res<AssetServer>) {
    // let task_pool = AsyncComputeTaskPool::get();

    // let task = task_pool.spawn(async move {});

    let texture: Handle<Image> = assets.load("img/Tileset Grass.png");
    let mut rng: Pcg64 = Seeder::from("default_seed").make_rng();
    let map_size = UVec2::new(1024, 1024);
    let tile_size = UVec2 { x: 16, y: 16 };
    commands
        .spawn((
            Tilemap,
            Name::new("Tilemap"),
            SpatialBundle {
                transform: Transform::from_xyz(0., 0., f32::MIN),
                ..default()
            },
        ))
        .with_children(|tilemap| {
            let layout = assets.add(TextureAtlasLayout::from_grid(
                tile_size,
                16,
                16,
                Some(UVec2 { x: 0, y: 0 }),
                Some(UVec2 { x: 0, y: 0 }),
            ));
            let u_center = (map_size * tile_size) / 2;
            let center = Vec2::new(u_center.x as f32, u_center.y as f32);
            for x in 0..map_size.x {
                for y in 0..map_size.y {
                    let u_pos = UVec2::new(x, y) * tile_size;
                    let pos = Vec2::new(u_pos.x as f32, u_pos.y as f32) - center;
                    let index = if rng.gen_range(0..1000) > 925 {
                        rng.gen_range(0..(16 * 8))
                    } else {
                        0
                    };
                    tilemap.spawn((
                        HideFromInspector,
                        SpriteBundle {
                            texture: texture.clone(),
                            transform: Transform::from_xyz(pos.x as f32, pos.y as f32, 0.),
                            ..default()
                        },
                        TextureAtlas {
                            layout: layout.clone(),
                            index,
                            ..default()
                        },
                    ));
                }
            }
        });
}

// pub fn spawn_in_background(mut commands: Commands, assets: Res<AssetServer>) {
//     let pool = AsyncComputeTaskPool::get();
//     let tilemap_entity = commands.spawn(Name::new("TilemapEntity")).id();
//     let texture_handle: Handle<Image> = assets.load("img/Tileset Grass.png");
//     let mut rng: Pcg64 = Seeder::from("default_seed").make_rng();
//     let map_size = UVec2::new(1024, 1024);
//     let tile_size = Vec2 { x: 16.0, y: 16.0 };
//     // tiletypes?
//     let task = pool.spawn(async move {
//         let mut queue = CommandQueue::default();
//         for x in 0..map_size.x {
//             for y in 0..map_size.y {
//                 let pos = Vec2::new(x as f32, y as f32) * tile_size;
//                 let texture_index = TileTextureIndex(if rng.gen_range(0..1000) > 925 {
//                     rng.gen_range(0..(16 * 8))
//                 } else {
//                     0
//                 });
//                 queue.push(move |world: &mut World| {
//                     let tile_entity = world
//                         .spawn((
//                             HideFromInspector,
//                             TileBundle {
//                                 position: tile_pos,
//                                 tilemap_id: TilemapId(tilemap_entity),
//                                 texture_index,
//                                 ..Default::default()
//                             },
//                         ))
//                         .id();
//                     tile_storage_ref.set(&tile_pos, tile_entity);
//                 });
//             }
//         }

//         queue.push(move |world: &mut World| {
//             world.spawn((
//                 Tilemap,
//                 Name::new("Tilemap"),
//                 TilemapBundle {
//                     grid_size,
//                     map_type,
//                     size,
//                     storage,
//                     texture,
//                     tile_size,
//                     transform: get_tilemap_center_transform(&size, &grid_size, &map_type, f32::MIN),
//                     ..default()
//                 },
//             ));
//         });

//         queue
//     });

//     commands.entity(tilemap_entity).insert(MapGen(task));
// }

// fn handle_tasks(mut commands: Commands, mut tasks: Query<&mut MapGen>) {
//     for mut task in &mut tasks {
//         if let Some(mut queue) = block_on(future::poll_once(&mut task.0)) {
//             commands.append(&mut queue);
//         }
//     }
// }

pub fn exit(mut commands: Commands, q: Query<Entity, With<Tilemap>>) {
    for id in q.iter() {
        commands.entity(id).despawn_recursive();
    }
}