extern crate gate;

use gate::{App, Audio};
use gate::app_info::AppInfo;
use gate::input::*;
use gate::renderer::{Renderer, Affine};

extern crate rand;

use rand::distributions::IndependentSample;
use rand::Isaac64Rng;
use std::f64::consts::PI;
use std::f64::consts::FRAC_PI_2;

mod asset_id { include!(concat!(env!("OUT_DIR"), "/asset_id.rs")); }
use asset_id::*;

mod geometry;
use geometry::*;
    
mod hitbox;
use hitbox::*;

mod entities;
use entities::bug::Bug;
use entities::home::Home;

struct BugBasherGame {
    rng: Isaac64Rng,
    bugs: Vec<Bug>,
    home: Home,
    points: i64,
    lives: i64,
    game_over: bool,
    time_to_next_bug: f64,
    total_time: f64,
    cursor_pos: Vec2d
}

impl App<AssetId> for BugBasherGame {
    fn start(&mut self, _audio: &mut Audio<AssetId>) {
    }

    fn advance(&mut self, seconds: f64, _audio: &mut Audio<AssetId>) -> bool {
        if !self.game_over {
            self.bugs.retain(|b| b.alive);
            for bug in self.bugs.iter_mut() {
                bug.advance(seconds);
                if self.home.touches_circle(bug) {
                    bug.alive = false;
                    self.lives -= 1;
                }
            }
            self.home.advance(seconds);
            if self.lives <= 0 {
                self.game_over = true;
            }
        
            self.time_to_next_bug -= seconds;
            self.total_time += seconds;
            
            if self.time_to_next_bug <= 0. {
                let mean = if self.total_time < 30. {
                    f64::max(4. - (self.total_time as f64 * 0.2), 1.)
                } else if self.total_time < 60. {
                    f64::max(1. - ((self.total_time as f64 - 30.) * 0.05), 0.5)
                } else if self.total_time < 90. {
                    f64::max(0.5 - ((self.total_time as f64 - 60.) * 0.05), 0.3)
                } else {
                    f64::max(0.3 - ((self.total_time as f64 - 90.) * 0.005), 0.2)
                };
                
                let sd = mean / 3.;
                let time_dist = rand::distributions::Normal::new(mean, sd);
                self.time_to_next_bug = time_dist.ind_sample(&mut self.rng);

                let angle_dist = rand::distributions::Range::new(0., 2.*PI);
                let angle = angle_dist.ind_sample(&mut self.rng);
                self.bugs.push(Bug::new(
                    angle.cos()*1000.,
                    angle.sin()*1000.
                ));
                
            }
        }
        
        true
    }

    fn input(&mut self, evt: InputEvent, _audio: &mut Audio<AssetId>) -> bool {
        match evt {
            InputEvent::MousePressed(MouseButton::Left, x, y) => {
                for bug in self.bugs.iter_mut().filter(|bug| bug.touches_point(Vec2d { x, y })) {
                    if !self.game_over && bug.alive == true {
                        self.points += 1;
                    }

                    bug.alive = false;
                }
            },
            InputEvent::MouseMotion(x, y) => {
                self.cursor_pos = Vec2d::new(x,y);
            },
            InputEvent::KeyPressed(KeyCode::Return) => {
                self.reset();
            },
            _ => {}
        }
        true
    }

    fn render(&mut self, renderer: &mut Renderer<AssetId>) {
        let (app_width, app_height) = (renderer.app_width(), renderer.app_height());
        renderer.clear((255,255,255));
        {
            let points_str = format!("{}", self.points);
            let lives_str = format!("{}", self.lives);
            BugBasherGame::print_string(renderer, &points_str, Alignment::Left, - app_width / 2. + 50., app_height / 2. - 50.);
            BugBasherGame::print_string(renderer, &lives_str, Alignment::Right, app_width / 2. - 50., app_height / 2. - 50.);
        }
        {
            let mut renderer = renderer.sprite_mode();
            renderer.draw(
                &Affine::translate(self.home.pos.x, self.home.pos.y),
                self.home.sprite
            );
            for bug in &self.bugs {
                let affine = if bug.rotation <= FRAC_PI_2 && bug.rotation >= -FRAC_PI_2 {
                    Affine::translate(bug.pos.x, bug.pos.y).pre_rotate(bug.rotation)
                } else {
                    Affine::translate(bug.pos.x, bug.pos.y).pre_rotate(bug.rotation).pre_scale_axes(1., -1.)
                };
                
                renderer.draw(
                    &affine,
                    SpriteId::Pom
                );
            }
        }
        
        if self.game_over {
            {
                let mut renderer = renderer.sprite_mode();
                renderer.draw(
                    &Affine::translate(0.,0.),
                    SpriteId::Gameover
                );
            }
            {
                let points_str = format!("{}", self.points);
                BugBasherGame::print_string(renderer, &points_str, Alignment::Center, 0., -25.);
            }
        }

        {
            let mut renderer = renderer.sprite_mode();
            renderer.draw(
                &Affine::translate(self.cursor_pos.x, self.cursor_pos.y),
                SpriteId::Cursor
            );
        }
    }
}

enum Alignment {
    Left,
    Right,
    Center
}

impl BugBasherGame {
    fn new() -> BugBasherGame {
        let mut game = BugBasherGame {
            rng: Isaac64Rng::new_unseeded(),
            home: Home::new(0., 0.),
            bugs: Vec::with_capacity(1000),
            points: 0,
            lives: 0,
            game_over: true,
            time_to_next_bug: 0.,
            total_time: 0.,
            cursor_pos: Vec2d::new(0.,0.)
        };
        game.reset();
        game
    }

    fn reset(&mut self) {
        self.bugs = Vec::with_capacity(1000);
        self.points = 0;
        self.lives = 3;
        self.game_over = false;
        self.time_to_next_bug = 0.;
        self.total_time = 0.;
    }

    fn print_string(renderer: &mut Renderer<AssetId>, string: &str, alignment: Alignment, x: f64, y: f64) {
        let letter_spacing = 45.;
        let left = match alignment {
            Alignment::Left => x,
            Alignment::Right => x - string.len() as f64 * letter_spacing,
            Alignment::Center => x - string.len() as f64 * letter_spacing / 2.
        };
        
        let mut renderer = renderer.tiled_mode(-left, -y);

        for (i, c) in string.chars().enumerate() {
            let affine = Affine::translate(i as f64 * letter_spacing, 0.);
            let tile = match c {
                '-' => TileId::NumberFontR0C0,
                '0' => TileId::NumberFontR0C1,
                '1' => TileId::NumberFontR0C2,
                '2' => TileId::NumberFontR0C3,
                '3' => TileId::NumberFontR0C4,
                '4' => TileId::NumberFontR0C5,
                '5' => TileId::NumberFontR0C6,
                '6' => TileId::NumberFontR0C7,
                '7' => TileId::NumberFontR0C8,
                '8' => TileId::NumberFontR0C9,
                '9' => TileId::NumberFontR0C10,
                _ => TileId::NumberFontR0C0,
            };
            renderer.draw(&affine, tile);
        };
    }
}

fn main() {
    let info = AppInfo::with_app_height(1000.).title("Bug Basher").build();
    gate::run(info, BugBasherGame::new());
}