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>);

pub fn spawn(mut commands: Commands, assets: Res<AssetServer>) {
    // TODO: I'm pretty determined to not have this sieze up the game. Should work with a "loading" screen.
    // let task_pool = AsyncComputeTaskPool::get();

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

    let mut rng: Pcg64 = Seeder::from("default_seed").make_rng();
    let size = TilemapSize::new(1024, 1024);
    let tilemap = commands.spawn((Tilemap, Name::new("Tilemap"))).id();

    let mut storage = TileStorage::empty(size);
    // let mutex_storage = Mutex::new(storage);

    for x in 0..size.x {
        for y in 0..size.y {
            let position = TilePos::new(x, y);
            let texture_index = TileTextureIndex(if rng.gen_range(0..1000) > 925 {
                rng.gen_range(0..(16 * 8))
            } else {
                0
            });
            let tile = commands
                .spawn((
                    HideFromInspector,
                    TileBundle {
                        position,
                        tilemap_id: TilemapId(tilemap),
                        texture_index,
                        ..Default::default()
                    },
                ))
                .id();
            storage.set(&position, tile);
        }
    }

    let texture = TilemapTexture::Single(assets.load("img/Tileset Grass.png"));
    let tile_size = TilemapTileSize::new(16., 16.);
    let grid_size = TilemapGridSize::new(16., 16.);
    let map_type = TilemapType::Square;

    commands.entity(tilemap).insert(TilemapBundle {
        grid_size,
        map_type,
        size,
        storage,
        texture,
        tile_size,
        transform: get_tilemap_center_transform(&size, &grid_size, &map_type, f32::MIN),
        ..Default::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();
    }
}