extern crate gate;

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

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

mod geometry;
use geometry::*;

mod entities;
use entities::bug::Bug;

struct BugBasherGame {
    bugs: Vec<Bug>,
    points: i64
}

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

    fn advance(&mut self, seconds: f64, _audio: &mut Audio<AssetId>) -> bool {
        self.bugs.retain(|b| b.alive);
        for bug in self.bugs.iter_mut() {
            bug.advance(seconds);
        }
        
        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() {
                    bug.click(Vec2d { x, y });
                }
            },
            _ => {}
        }
        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 mut renderer = renderer.tiled_mode(app_width / 2. - 50., -app_height / 2. + 50.);
            let spacing = 25.;
            let point_str = format!("{}", self.points);
            for (i, c) in point_str.chars().enumerate() {
                let affine = Affine::translate(i as f64 * 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);
            };
            
        }
        {
            let mut renderer = renderer.sprite_mode();
            for bug in &self.bugs {
                renderer.draw(
                    &Affine::translate(bug.pos.x, bug.pos.y).pre_rotate(bug.rotation),
                    SpriteId::Bug
                );
            }
        }
    }
}

impl BugBasherGame {
}

fn main() {
    let info = AppInfo::with_app_height(1000.).title("Bug Basher").build();
    gate::run(info, BugBasherGame {
        bugs: vec!(
            Bug::new(500., 200., 0.3),
            Bug::new(-200., -200., 1.5),
            Bug::new(-1000., 200., 0.),
            Bug::new(1200., 0., 0.3),
            Bug::new(-1300., 0., 1.5),
            Bug::new(0., 1100., 0.),
            Bug::new(0., -1500., 0.3),
            Bug::new(300., -1200., 1.5),
        ),
        points: 0
    });
}