use bevy::math::Vec3;
use bevy::prelude::*;
use bevy::render::texture::ImageSettings;
use gems::cell::{self, AnimationTimer, Cell, Occupant};
use gems::constants;
use rand::{thread_rng, Rng};
use std::time::Duration;

fn star_spawning(
    mut commands: Commands,
    time: Res<Time>,
    mut query: Query<(&mut AnimationTimer, &Handle<TextureAtlas>)>,
) {
    for (mut timer, texture_atlas_handle) in &mut query {
        if !timer.repeating() {
            timer.tick(time.delta());
            if timer.just_finished() {
                timer.set_duration(Duration::new(thread_rng().gen_range(2..5), 0));
                timer.reset();
                commands
                    .spawn_bundle(SpriteSheetBundle {
                        sprite: TextureAtlasSprite::new(constants::TILESHEET_STAR1),
                        texture_atlas: texture_atlas_handle.clone(),
                        transform: Transform {
                            translation: Vec3::new(
                                thread_rng().gen_range(-300.0..300.0),
                                thread_rng().gen_range(-200.0..300.0),
                                0.1,
                            ),
                            scale: Vec3::splat(thread_rng().gen_range(1.0..3.0)),
                            ..Default::default()
                        },
                        ..Default::default()
                    })
                    .insert(AnimationTimer::from_seconds(0.15, true));
            }
        }
    }
}

pub fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
) {
    let background = asset_server.load("background.png");
    let tileset = asset_server.load("tileset.png");
    let title = asset_server.load("title.png");

    let atlas = TextureAtlas::from_grid(
        tileset,
        Vec2::new(constants::TILE_SIZE, constants::TILE_SIZE),
        5,
        5,
    );
    let atlas_handle = texture_atlases.add(atlas);

    commands.spawn_bundle(Camera2dBundle::default());
    commands.spawn_bundle(SpriteBundle {
        texture: background,
        transform: Transform {
            translation: Vec3::new(50.0, 0.0, 0.0),
            scale: Vec3::splat(constants::TILE_SCALE),
            ..Default::default()
        },
        ..Default::default()
    });
    commands.spawn_bundle(SpriteBundle {
        texture: title,
        transform: Transform {
            translation: Vec3::new(240.0, 200.0, 0.2),
            scale: Vec3::splat(2.0),
            ..Default::default()
        },
        ..Default::default()
    });
    commands.spawn_bundle(SpriteSheetBundle {
        sprite: TextureAtlasSprite::new(constants::TILESHEET_COSMONAUT1),
        texture_atlas: atlas_handle.clone(),
        transform: Transform {
            translation: Vec3::new(225.0, -200.0, 0.2),
            scale: Vec3::splat(constants::TILE_SCALE),
            ..Default::default()
        },
        ..Default::default()
    });
    commands.spawn_bundle((
        AnimationTimer::from_seconds(1.0, false),
        atlas_handle.clone(),
    ));
    commands.spawn_bundle(SpriteSheetBundle {
        sprite: TextureAtlasSprite::new(constants::TILESHEET_COSMONAUT2),
        texture_atlas: atlas_handle.clone(),
        transform: Transform {
            translation: Vec3::new(
                225.0,
                -200.0 + (-constants::TILE_SIZE) * constants::TILE_SCALE,
                0.2,
            ),
            scale: Vec3::splat(constants::TILE_SCALE),
            ..Default::default()
        },
        ..Default::default()
    });

    for i in 0..constants::GRID_SIZE {
        for j in 0..constants::GRID_SIZE {
            commands
                .spawn_bundle(SpriteSheetBundle {
                    texture_atlas: atlas_handle.clone(),
                    visibility: Visibility { is_visible: false },
                    transform: Transform {
                        translation: Vec3::new(
                            ((i as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 330.0,
                            ((j as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 160.0,
                            0.2,
                        ),
                        scale: Vec3::splat(constants::TILE_SCALE),
                        ..Default::default()
                    },
                    ..Default::default()
                })
                .insert(Cell::new(i, j));
        }
    }
}

fn animation(
    mut commands: Commands,
    time: Res<Time>,
    mut q: Query<(
        Entity,
        Option<&mut Cell>,
        &mut AnimationTimer,
        &mut TextureAtlasSprite,
        &mut Visibility,
    )>,
) {
    for (entity, cell, mut timer, mut sprite, mut visibility) in q.iter_mut() {
        timer.tick(time.delta());
        if timer.finished() {
            let index = match sprite.index {
                constants::TILESHEET_EXPLOSION1 => Some(constants::TILESHEET_EXPLOSION2),
                constants::TILESHEET_EXPLOSION2 => Some(constants::TILESHEET_EXPLOSION3),
                constants::TILESHEET_EXPLOSION3 => Some(constants::TILESHEET_EXPLOSION4),
                constants::TILESHEET_EXPLOSION4 => Some(constants::TILESHEET_EXPLOSION5),

                constants::TILESHEET_VISOR1 => Some(constants::TILESHEET_VISOR2),
                constants::TILESHEET_VISOR2 => Some(constants::TILESHEET_VISOR3),
                constants::TILESHEET_VISOR3 => Some(constants::TILESHEET_VISOR4),

                constants::TILESHEET_STAR1 => Some(constants::TILESHEET_STAR2),
                constants::TILESHEET_STAR2 => Some(constants::TILESHEET_STAR3),

                _ => None,
            };

            if let Some(index) = index {
                sprite.index = index;
            } else if let Some(mut cell) = cell {
                cell.set_occupant(Occupant::None, &mut sprite, &mut visibility);
                commands.entity(entity).remove::<AnimationTimer>();
            } else {
                commands.entity(entity).despawn();
            }
        }
    }
}

fn cosmonaut_detect(
    mut commands: Commands,
    windows: Res<Windows>,
    mut q: Query<(&Transform, &TextureAtlasSprite, &Handle<TextureAtlas>)>,
) {
    if let Some(mut cursor_position) = windows
        .get_primary()
        .and_then(|window| window.cursor_position())
    {
        cursor_position.x -=
            (constants::WINDOW_WIDTH / 2.0) - constants::TILE_SIZE * constants::TILE_SCALE * 0.5;
        cursor_position.y -=
            (constants::WINDOW_HEIGHT / 2.0) - constants::TILE_SIZE * constants::TILE_SCALE * 0.5;
        for (transform, sprite, texture_atlas_handle) in q.iter_mut() {
            if transform.translation.x < cursor_position.x
                && transform.translation.x + constants::TILE_SIZE * constants::TILE_SCALE
                    > cursor_position.x
                && transform.translation.y < cursor_position.y
                && transform.translation.y + constants::TILE_SIZE * constants::TILE_SCALE
                    > cursor_position.y
                && sprite.index == constants::TILESHEET_COSMONAUT1
            {
                commands
                    .spawn_bundle(SpriteSheetBundle {
                        sprite: TextureAtlasSprite::new(constants::TILESHEET_VISOR1),
                        texture_atlas: texture_atlas_handle.clone(),
                        transform: *transform,
                        ..Default::default()
                    })
                    .insert(AnimationTimer::from_seconds(0.1, true));
            }
        }
    }
}

fn mouse(
    windows: Res<Windows>,
    mut q: Query<(&mut Cell, &mut Transform, &mut TextureAtlasSprite)>,
    mouse_button_input: Res<Input<MouseButton>>,
) {
    if let Some(mut cursor_position) = windows
        .get_primary()
        .and_then(|window| window.cursor_position())
    {
        cursor_position.x -=
            (constants::WINDOW_WIDTH / 2.0) - constants::TILE_SIZE * constants::TILE_SCALE * 0.5;
        cursor_position.y -=
            (constants::WINDOW_HEIGHT / 2.0) - constants::TILE_SIZE * constants::TILE_SCALE * 0.5;

        for (cell, _, mut sprite) in q.iter_mut() {
            if cell.selected {
                sprite.color.set_a(0.2);
            } else if cell.hovered {
                sprite.color.set_a(0.5);
            } else {
                sprite.color.set_a(1.0);
            }
        }

        for (mut cell, transform, _) in q.iter_mut() {
            if transform.translation.x < cursor_position.x
                && transform.translation.x + constants::TILE_SIZE * constants::TILE_SCALE
                    > cursor_position.x
                && transform.translation.y < cursor_position.y
                && transform.translation.y + constants::TILE_SIZE * constants::TILE_SCALE
                    > cursor_position.y
            {
                cell.hovered = true;
                if mouse_button_input.just_pressed(MouseButton::Left) {
                    cell.selected = true;
                }
            } else {
                cell.hovered = false;
            }
        }

        if mouse_button_input.just_released(MouseButton::Left) {
            let mut cells: Vec<Cell> = Vec::new();
            for (cell, _, _) in q.iter_mut() {
                cells.push(*cell);
            }
            if let Some(selected) = cells.clone().iter_mut().find(|c| c.selected) {
                if let Some(hovered) = cells.iter_mut().find(|c| c.hovered) {
                    if ((selected.x == hovered.x + 1
                        || selected.x == hovered.x.overflowing_sub(1).0)
                        && selected.y == hovered.y)
                        || ((selected.y == hovered.y + 1
                            || selected.y == hovered.y.overflowing_sub(1).0)
                            && selected.x == hovered.x)
                    {
                        std::mem::swap(&mut selected.occupant, &mut hovered.occupant);
                        for (mut cell, _, mut sprite) in q.iter_mut() {
                            if cell.x == selected.x && cell.y == selected.y {
                                cell.occupant = selected.occupant;
                                sprite.index = cell.occupant.to_index();
                            } else if cell.x == hovered.x && cell.y == hovered.y {
                                cell.occupant = hovered.occupant;
                                sprite.index = cell.occupant.to_index();
                            }
                        }
                    }
                }
            }
            for (mut cell, _, _) in q.iter_mut() {
                cell.selected = false;
            }
        }
    }
}

pub fn main() {
    App::new()
        .insert_resource(ImageSettings::default_nearest())
        .insert_resource(WindowDescriptor {
            title: "gems".to_string(),
            width: constants::WINDOW_WIDTH,
            height: constants::WINDOW_HEIGHT,
            resizable: false,
            ..Default::default()
        })
        .add_plugins(DefaultPlugins)
        .add_startup_system(setup)
        .add_system(cell::insert)
        .add_system(cell::falling)
        .add_system(cell::check)
        .add_system(cell::start_explosion)
        .add_system(mouse)
        .add_system(cosmonaut_detect)
        .add_system(animation)
        .add_system(star_spawning)
        .run();
}