#![windows_subsystem = "windows"]

extern crate piston;
extern crate graphics;
extern crate opengl_graphics;
extern crate fps_counter;
extern crate rand;
extern crate find_folder;
extern crate piston_window;

use piston::window::*;
use piston::event_loop::*;
use piston::input::{RenderEvent, PressEvent, MouseCursorEvent, Button, UpdateEvent, UpdateArgs, Key, ReleaseEvent};
use opengl_graphics::{GlGraphics, OpenGL, Texture, TextureSettings};
use graphics::{Image, clear};
use graphics::draw_state::DrawState;
use graphics::rectangle::square;
use std::path::Path;
use std::collections::HashMap;
use std::string::String;
use std::process;
use rand::prelude::*;
use piston_window::*;

fn main() {

    let opengl = OpenGL::V3_2;
    let mut window: PistonWindow = WindowSettings::new("SpaceO's", [600, 600])
    .opengl(opengl).exit_on_esc(true).vsync(true).decorated(true).build().unwrap();

    let mut fps_counter = fps_counter::FPSCounter::new();
    let mut events: Events = Events::new(EventSettings::new().ups(120).max_fps(62));
    let mut gl = GlGraphics::new(opengl);
    let mut rng = thread_rng();
    
    let mut glyphs = init_font("font.ttf".to_string(), &mut window);

    let mut menu: MainMenu = MainMenu{
        textures: HashMap::new(),
        images: HashMap::new(), 
        onmenu: true,
        mouse_x: 0.0,
        mouse_y: 0.0,
        play: false,
        quit: false,
    };

    menu.init();

    let mut gameover: GameOver = GameOver{
        textures: HashMap::new(),
        images: HashMap::new(), 
        ongameover: false,
        mouse_x: 0.0,
        mouse_y: 0.0,
        play: false,
        quit: false,
    };

    gameover.init();

    let mut player: Player = Player {
        texture: Texture::from_path(Path::new(&"assets/player.png"),&TextureSettings::new()).unwrap(),
        pos_x: (600.0/2.0)-120.0,
        pos_y: 545.0,
        size: 60.0,
        up_d: false,
        down_d: false, 
        left_d: false, 
        right_d: false,
        life: 3, 
        score: 0,
    };

    let mut background: Background = Background {
        texture: Texture::from_path(Path::new(&"assets/bgs.png"),&TextureSettings::new()).unwrap(),
        pos_y: 0.0,
        down: true,
    };

    let mut level: Level = Level {
        vague: 1,
        multiplier: 1,
        verif_vague: 0,
        d_ennemi: 0,
        meteors: Vec::new(),
    };

    let mut life: DLife = DLife {
        coeurs_i: HashMap::new(),
        texture: Texture::from_path(Path::new(&"assets/coeur.png"),&TextureSettings::new()).unwrap(),
    };

    level.pass_level(false);
    life.init();

    let mut final_score = 0;

    while let Some(e) = events.next(&mut window) {

        //Mouvement de souris & click de souris + update pour le menu
        if menu.onmenu {
            menu.mouse_move(&e);
            menu.mouse_click(&e);
            if let Some(u) = e.update_args() {
                menu.update(&u);
            }
        }else if gameover.ongameover {
            gameover.mouse_move(&e);
            gameover.mouse_click(&e);
            if let Some(u) = e.update_args() {
                gameover.update(&u);
            }
        }else{
            if let Some(u) = e.update_args() {
                background.move_background();
                player.update(&u);
            }
            if let Some(b) = e.press_args() {
                player.press_player(&b);
            }
            if let Some(b) = e.release_args() {
                player.rel_player(&b);
            }
            final_score = 0;
        }

        if let Some(r) = e.render_args() {

            gl.draw(r.viewport(), |c, gl| {

                clear([1.0, 1.0, 1.0, 1.0], gl);

                //Affichage des < sur le menu principal
                if menu.onmenu {

                    menu.images.get("background").unwrap().draw(menu.textures.get("background").unwrap(), &DrawState::new_alpha(), c.transform, gl);

                    if menu.play {
                        menu.images.get("surcouche_on_play").unwrap().draw(menu.textures.get("surcouche_on_play").unwrap(), &DrawState::new_alpha(), c.transform, gl);
                    }else{
                        menu.images.get("surcouche_off_play").unwrap().draw(menu.textures.get("surcouche_off_play").unwrap(), &DrawState::new_alpha(), c.transform, gl);
                    }
                    
                    if menu.quit {
                        menu.images.get("surcouche_on_quit").unwrap().draw(menu.textures.get("surcouche_on_quit").unwrap(), &DrawState::new_alpha(), c.transform, gl);
                    }else{
                        menu.images.get("surcouche_off_quit").unwrap().draw(menu.textures.get("surcouche_off_quit").unwrap(), &DrawState::new_alpha(), c.transform, gl);
                    }

                }else if gameover.ongameover {

                    gameover.images.get("background").unwrap().draw(gameover.textures.get("background").unwrap(), &DrawState::new_alpha(), c.transform, gl);

                    if gameover.play {
                        gameover.images.get("gameover_surcouche_on_play").unwrap().draw(gameover.textures.get("gameover_surcouche_on_play").unwrap(), &DrawState::new_alpha(), c.transform, gl);
                    }else{
                        gameover.images.get("gameover_surcouche_off_play").unwrap().draw(gameover.textures.get("gameover_surcouche_off_play").unwrap(), &DrawState::new_alpha(), c.transform, gl);
                    }
                    
                    if gameover.quit {
                        gameover.images.get("gameover_surcouche_on_quit").unwrap().draw(gameover.textures.get("gameover_surcouche_on_quit").unwrap(), &DrawState::new_alpha(), c.transform, gl);
                    }else{
                        gameover.images.get("gameover_surcouche_off_quit").unwrap().draw(gameover.textures.get("gameover_surcouche_off_quit").unwrap(), &DrawState::new_alpha(), c.transform, gl);
                    }

                }else {
                    Image::new().rect(square(0.0, background.pos_y, 1800.0)).draw(&background.texture, &DrawState::new_alpha(), c.transform, gl);
                    Image::new().rect(square(player.pos_x, player.pos_y, player.size)).draw(&player.texture, &DrawState::new_alpha(), c.transform, gl);

                    //Meteor
                    for i in 0..level.meteors.len() {
                        if i < level.meteors.len() {
                            level.meteors[i].move_meteor();
                            level.meteors[i].draw().draw(&level.meteors[i].texture, &DrawState::new_alpha(), c.transform, gl);
                            if level.meteors[i].collide(player.pos_x, player.pos_y){
                                level.meteors[i].pos_x = rng.gen_range(20, 570) as f64;
                                level.meteors[i].pos_y = rng.gen_range(-650, -50) as f64;
                                if player.life == 1 {
                                    life.coeurs_i.remove(&3);
                                }else if player.life == 2 {
                                    life.coeurs_i.remove(&2);
                                }else if player.life == 3 {
                                    life.coeurs_i.remove(&1);
                                }
                                player.life-=1;
                                if player.life == 0 {
                                    //Game Over
                                    gameover.ongameover = true;
                                    final_score = player.score;
                                    life.init();
                                    player.life = 3;
                                    level.multiplier = 1;
                                    menu.play = false;
                                    menu.quit = false;
                                    gameover.play = false;
                                    gameover.quit = false;
                                    player.up_d = false;
                                    player.down_d = false; 
                                    player.left_d = false; 
                                    player.right_d = false;
                                    player.score = 0;
                                    level.vague =  1;
                                    level.verif_vague = 0;
                                    level.d_ennemi = 0;
                                    level.meteors = Vec::new();
                                    level.pass_level(false);
                                    player.pos_x = (600.0/2.0)-120.0;
                                    player.pos_y = 545.0;
                                    return;
                                }
                            }
                            if !menu.onmenu{
                                if level.meteors[i].pos_y > 570.0 {
                                    level.check_level(&mut player);
                                    //println!("{}", player.score);
                                    level.meteors[i].pos_x = rng.gen_range(20, 570) as f64;
                                    level.meteors[i].pos_y = rng.gen_range(-650, -50) as f64;
                                }
                            }
                        }   
                    }
                    //level.meteor(&mut player, &mut c, &mut gl);
                    

                    //Life draw
                    for (_key, img) in &life.coeurs_i {
                        img.draw(&life.texture, &DrawState::new_alpha(), c.transform, gl);
                    }
                }
            });

            if menu.onmenu{
                //Pas de text pour le main menu
            }else if gameover.ongameover {
                window.draw_2d(&e, |c, g| {
                    let transform = c.transform.trans(150.0, 200.0);
                    text::Text::new_color([1.0, 1.0, 1.0, 1.0], 30).draw(&format!("Score: {}",final_score),&mut glyphs,&c.draw_state,transform, g).unwrap();
                });
            }else{
                window.draw_2d(&e, |c, g| {
                    let transform = c.transform.trans(465.0, 30.0);
                    text::Text::new_color([1.0, 1.0, 1.0, 1.0], 10).draw(&format!("Score: {}",player.score),&mut glyphs,&c.draw_state,transform, g).unwrap();
                });
            }
            
            window.set_title(format!("SpaceO's FPS: {}",fps_counter.tick()));
        }
    }
}

fn init_font(s: String, window: &mut PistonWindow) -> Glyphs{
    let assets = find_folder::Search::ParentsThenKids(3, 3).for_folder("assets").unwrap();
    let ref font = assets.join(s);
    let factory = window.factory.clone();
    return Glyphs::new(font, factory, TextureSettings::new()).unwrap();
}