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

fn star_spawning_system(commands: &mut Commands, time: Res<Time>, mut q: Query<&mut Timer>) {
    for mut timer in q.iter_mut() {
        if !timer.repeating() {
            timer.tick(time.delta_seconds());
            if timer.just_finished() {
                timer.set_duration(thread_rng().gen_range(2..5) as f32);
                timer.reset();
                commands
                    .spawn(SpriteSheetBundle {
                        sprite: TextureAtlasSprite::new(16),
                        transform: Transform {
                            translation: Vec3 {
                                x: thread_rng().gen_range(-300..300) as f32,
                                y: thread_rng().gen_range(-200..300) as f32,
                                z: 0.0,
                            },
                            scale: Vec3::splat(thread_rng().gen_range(1..3) as f32),
                            ..Default::default()
                        },
                        ..Default::default()
                    })
                    .with(Timer::from_seconds(0.25, true));
            }
        }
    }
}

pub fn setup(
    commands: &mut 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(16.0, 16.0), 4, 5);
    let atlas_handle = texture_atlases.add(atlas);

    commands
        .spawn(Camera2dBundle::default())
        .spawn(SpriteBundle {
            material: materials.add(background.into()),
            transform: Transform {
                translation: Vec3 {
                    x: 50.0,
                    y: 0.0,
                    z: 0.0,
                },
                scale: Vec3::splat(3.5),
                ..Default::default()
            },
            ..Default::default()
        })
        .spawn(SpriteSheetBundle {
            sprite: TextureAtlasSprite::new(8),
            texture_atlas: atlas_handle.clone(),
            transform: Transform {
                translation: Vec3 {
                    x: 225.0,
                    y: -200.0,
                    z: 0.0,
                },
                scale: Vec3::splat(3.5),
                ..Default::default()
            },
            ..Default::default()
        })
        .spawn((Timer::from_seconds(1.0, false),))
        .spawn(SpriteSheetBundle {
            sprite: TextureAtlasSprite::new(12),
            texture_atlas: atlas_handle.clone(),
            transform: Transform {
                translation: Vec3 {
                    x: 225.0,
                    y: -200.0 + (-16.0) * 3.5,
                    z: 0.0,
                },
                scale: Vec3::splat(3.5),
                ..Default::default()
            },
            ..Default::default()
        });

    for i in 0..constants::COLUMNS {
        for j in 0..constants::ROWS {
            commands
                .spawn(SpriteSheetBundle {
                    texture_atlas: atlas_handle.clone(),
                    sprite: TextureAtlasSprite::new(11),
                    transform: Transform {
                        translation: Vec3 {
                            x: ((i as f32) * 16.0 * 3.5) - 320.0,
                            y: ((j as f32) * 16.0 * 3.5) - 160.0,
                            z: 1.0,
                        },
                        scale: Vec3::splat(3.5),
                        ..Default::default()
                    },
                    ..Default::default()
                })
                .with(Cell::new(i, j));
        }
    }
}

fn animation_system(
    commands: &mut Commands,
    time: Res<Time>,
    mut cell_query: Query<(Entity, &mut Timer, &mut TextureAtlasSprite), Without<Cell>>,
) {
    for (entity, mut timer, mut sprite) in cell_query.iter_mut() {
        timer.tick(time.delta_seconds());
        if timer.finished() {
            let index = match sprite.index {
                9 => 10,
                10 => 13,
                13 => 14,
                11 => 12,
                16 => 17,
                17 => 18,
                _ => 11,
            };
            sprite.index = index;
            if index == 12 {
                commands.despawn(entity);
            }
        }
    }
}

fn cosmonaut_detect_system(
    commands: &mut Commands,
    windows: Res<Windows>,
    mut cell_query: Query<(&Transform, &TextureAtlasSprite)>,
) {
    if let Some(mut cursor_position) = windows
        .get_primary()
        .and_then(|window| window.cursor_position())
    {
        cursor_position.x -= 400.0 - 16.0 * 3.5 * 0.5;
        cursor_position.y -= 300.0 - 16.0 * 3.5 * 0.5;
        for (transform, sprite) in cell_query.iter_mut() {
            if transform.translation.x < cursor_position.x
                && transform.translation.x + 16.0 * 3.5 > cursor_position.x
                && transform.translation.y < cursor_position.y
                && transform.translation.y + 16.0 * 3.5 > cursor_position.y
                && sprite.index == 8
            {
                commands
                    .spawn(SpriteSheetBundle {
                        sprite: TextureAtlasSprite::new(9),
                        transform: *transform,
                        ..Default::default()
                    })
                    .with(Timer::from_seconds(0.1, true));
            }
        }
    }
}

fn mouse_system(
    windows: Res<Windows>,
    mut cell_query: 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 -= 400.0 - 16.0 * 3.5 * 0.5;
        cursor_position.y -= 300.0 - 16.0 * 3.5 * 0.5;

        for (cell, _, mut sprite) in cell_query.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, mut sprite) in cell_query.iter_mut() {
            if transform.translation.x < cursor_position.x
                && transform.translation.x + 16.0 * 3.5 > cursor_position.x
                && transform.translation.y < cursor_position.y
                && transform.translation.y + 16.0 * 3.5 > cursor_position.y
            {
                cell.hovered = true;
                sprite.color.set_a(0.5);
                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 cell_query.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 cell_query.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 cell_query.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::explosion_animation.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()
        .add_resource(WindowDescriptor {
            title: "gems".to_string(),
            width: 800.0,
            height: 600.0,
            resizable: false,
            ..Default::default()
        })
        .add_plugins(DefaultPlugins)
        .add_plugin(GemsPlugin)
        .run();
}