use bevy::{
    asset::{self, LoadState},
    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
    ecs::schedule::ScheduleLabel,
    math::{uvec2, vec2},
    prelude::*,
    render::{render_resource::FilterMode, texture::ImageSampler},
    window::PresentMode,
};
use bevy_fast_tilemap::{map::DefaultUserData, FastTileMapPlugin, Map, MapBundleManaged};

mod mouse_controls_camera;
use mouse_controls_camera::MouseControlsCameraPlugin;

#[derive(Resource)]
struct TileTerrainIndices(Vec<u32>);
#[derive(Resource)]
struct TextureAtlasHandle(Handle<Image>);

fn main() {
    App::new()
        .add_plugins((
            DefaultPlugins.set(WindowPlugin {
                primary_window: Some(Window {
                    title: String::from("Fast Tilemap example"),
                    resolution: (1820., 420.).into(),
                    // disable vsync so we can see the raw FPS speed
                    present_mode: PresentMode::Immediate,
                    ..default()
                }),
                ..default()
            }),
            LogDiagnosticsPlugin::default(),
            // FrameTimeDiagnosticsPlugin::default(),
            MouseControlsCameraPlugin::default(),
            FastTileMapPlugin::default(),
        ))
        .add_systems(Startup, startup)
        .add_systems(Update, ensure_texture_filter)
        // .add_systems(FixedUpdate, update_map)
        // Performance-wise you can step this much faster but it'd require an epillepsy warning.
        .insert_resource(Time::<Fixed>::from_seconds(0.2))
        .run();
}

fn ensure_texture_filter(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut materials: ResMut<Assets<Map>>,
    mut images: ResMut<Assets<Image>>,
    mut done: Local<bool>,
    handle: Res<TextureAtlasHandle>,
    tile_terrain_indices: Res<TileTerrainIndices>,
) {
    if dbg!(*done) {
        return;
    }

    let handle = handle.0.clone();
    if dbg!(asset_server.load_state(&handle)) != LoadState::Loaded {
        return;
    }

    let atlas = images.get_mut(&handle).unwrap();
    atlas.sampler = ImageSampler::nearest();

    let map = Map::builder(uvec2(100, 100), handle, vec2(16., 16.))
        .with_padding(vec2(2., 2.), vec2(0., 0.), vec2(0., 0.))
        .build_and_initialize(|m| {
            // Initialize using a closure
            // Set all tiles in layer 0 to index 6
            for y in 0..m.size().y {
                for x in 0..m.size().y {
                    m.set(x, y, tile_terrain_indices.0[(x * 100 + y) as usize] - 1);
                }
            }
        });

    commands.spawn(MapBundleManaged {
        material: materials.add(map),
        ..default()
    });

    *done = true;
}

fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn(Camera2dBundle::default());
    let handle = asset_server.load::<Image>("sprite_images/atlas-1.png");
    commands.insert_resource(TextureAtlasHandle(handle));

    let tiled_map_json = std::fs::read_to_string("./assets/SimpleMap.json").unwrap();
    let json = serde_json::from_str::<serde_json::Value>(&tiled_map_json).unwrap();
    let data = json
        .get("layers")
        .unwrap()
        .as_array()
        .unwrap()
        .get(0)
        .unwrap()
        .get("data")
        .unwrap()
        .as_array()
        .unwrap();
    let data = data
        .iter()
        .map(|v| serde_json::from_value::<u32>(v.clone()).unwrap())
        .collect::<Vec<_>>();
    commands.insert_resource(TileTerrainIndices(data));
}

// Create map with the given dimensions of our chunk
        let map = Map::builder(
            // Map size (tiles)
            uvec2(
                chunk.get_chunk_dimensions().x,
                chunk.get_chunk_dimensions().y,
            ),
            // Tile atlas
            asset_server.load("tiles_16.png"),
            // Tile size (pixels)
            vec2(16., 16.),
        )
        .build_and_set(&mut images, |pos| rng.gen_range(0..15));

        commands
            .entity(entity)
            .insert((
                SpatialBundle {
                    transform: Transform {
                        translation: Vec3::new(
                            chunk.chunk_pos.x() as f32
                                * chunk.get_chunk_dimensions().x as f32
                                * 16.0,
                            chunk.chunk_pos.y() as f32
                                * chunk.get_chunk_dimensions().y as f32
                                * 16.0,
                            1.0,
                        ),
                        ..default()
                    },
                    ..default()
                },
                ChunkMapSpawned,
            ))
            .with_children(|parent| {
                let mut map_bundle = MapBundle::new(map);
                map_bundle.transform.translation = Vec3::new(
                    chunk.chunk_pos.x() as f32 * chunk.get_chunk_dimensions().x as f32 * 16.0,
                    chunk.chunk_pos.y() as f32 * chunk.get_chunk_dimensions().y as f32 * 16.0,
                    1.0,
                );
                parent
                    .spawn(map_bundle)
                    .insert(Transform::from_translation(Vec3::new(1.0, 1.0, 1.0)))
                    // Have the map manage our mesh so it always has the right size
                    .insert(MeshManagedByMap)
                    .insert(FastTileMap);
            });

            vec2(4. * TILE_SIZE.x, 4. * TILE_SIZE.y), // inner
            vec2(2. * TILE_SIZE.x, 4. * TILE_SIZE.y), // lefttop
            vec2(2. * TILE_SIZE.x, 0. * TILE_SIZE.y), // rightbottom