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

fn star_spawning_system(mut commands: Commands, time: Res<Time>, mut q: Query<&mut Timer>) {
    for mut timer in q.iter_mut() {
        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),
                        transform: Transform {
                            translation: Vec3::new(
                                thread_rng().gen_range(-300..300) as f32,
                                thread_rng().gen_range(-200..300) as f32,
                                0.0,
                            ),
                            scale: Vec3::splat(thread_rng().gen_range(1..3) as f32),
                            ..Default::default()
                        },
                        ..Default::default()
                    },
                    Timer::from_seconds(0.25, true),
                ));
            }
        }
    }
}

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

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

    commands.spawn_bundle(OrthographicCameraBundle::new_2d());
    commands.spawn_bundle(SpriteBundle {
        material: materials.add(background.into()),
        transform: Transform {
            translation: Vec3::new(50.0, 0.0, 0.0),
            scale: Vec3::splat(constants::TILE_SCALE),
            ..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.0),
            scale: Vec3::splat(constants::TILE_SCALE),
            ..Default::default()
        },
        ..Default::default()
    });
    commands.spawn_bundle((Timer::from_seconds(1.0, false),));
    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.0,
            ),
            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(),
                    sprite: TextureAtlasSprite::new(constants::TILESHEET_NONE1),
                    transform: Transform {
                        translation: Vec3::new(
                            ((i as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 320.0,
                            ((j as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 160.0,
                            1.0,
                        ),
                        scale: Vec3::splat(constants::TILE_SCALE),
                        ..Default::default()
                    },
                    ..Default::default()
                },
                Cell::new(i, j),
            ));
        }
    }
}

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

                constants::TILESHEET_VISOR1 => constants::TILESHEET_VISOR2,
                constants::TILESHEET_VISOR2 => constants::TILESHEET_VISOR3,
                constants::TILESHEET_VISOR3 => constants::TILESHEET_VISOR4,

                constants::TILESHEET_STAR1 => constants::TILESHEET_STAR2,
                constants::TILESHEET_STAR2 => constants::TILESHEET_STAR3,

                constants::TILESHEET_NONE1 => constants::TILESHEET_NONE2,
                _ => constants::TILESHEET_NONE1,
            };
            sprite.index = index;
            if index == constants::TILESHEET_NONE2 {
                if let Some(mut cell) = cell {
                    cell.occupant = Occupant::None;
                    sprite.index = cell.occupant.to_index();
                    commands.entity(entity).remove::<Timer>();
                } else {
                    commands.entity(entity).despawn();
                }
            }
        }
    }
}

fn cosmonaut_detect_system(
    mut commands: Commands,
    windows: Res<Windows>,
    mut q: Query<(&Transform, &TextureAtlasSprite)>,
) {
    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) 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),
                        transform: *transform,
                        ..Default::default()
                    },
                    Timer::from_seconds(0.1, true),
                ));
            }
        }
    }
}

fn mouse_system(
    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(mut selected) = cells.clone().iter_mut().find(|c| c.selected) {
                if let Some(mut hovered) = cells.iter_mut().find(|c| c.hovered) {
                    if (selected.x == hovered.x + 1 && selected.y == hovered.y)
                        || (selected.x == hovered.x.overflowing_sub(1).0 && selected.y == hovered.y)
                        || (selected.y == hovered.y + 1 && selected.x == hovered.x)
                        || (selected.y == hovered.y.overflowing_sub(1).0 && selected.x == hovered.x)
                    {
                        let tmp = selected.occupant;
                        selected.occupant = hovered.occupant;
                        hovered.occupant = tmp;
                        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 struct GemsPlugin;
impl Plugin for GemsPlugin {
    fn build(&self, app: &mut AppBuilder) {
        app.add_startup_system(setup.system());
        app.add_system(cell::insert.system());
        app.add_system(cell::falling.system());
        app.add_system(cell::check.system());
        app.add_system(cell::start_explosion.system());
        app.add_system(mouse_system.system());
        app.add_system(cosmonaut_detect_system.system());
        app.add_system(animation_system.system());
        app.add_system(star_spawning_system.system());
    }
}

pub fn main() {
    App::build()
        .insert_resource(WindowDescriptor {
            title: "gems".to_string(),
            width: constants::WINDOW_WIDTH,
            height: constants::WINDOW_HEIGHT,
            resizable: false,
            ..Default::default()
        })
        .add_plugins(DefaultPlugins)
        .add_plugin(GemsPlugin)
        .run();
}