use sdl2::render::Canvas;
use sdl2::video::Window;

use std::{thread, time};
use std::time::{SystemTime};

use microworlds::Engine;
use microworlds::Grid;

pub const SCREEN_SIZE: u32 = 800;
pub const PX_SIZE: u32 = 2;
pub const STEPS_PER_SEC: u64 = 8;

fn main() {
    let sdl_context = sdl2::init().unwrap();
    let video_subsystem = sdl_context.video().unwrap();
    let window = video_subsystem.window("Microworlds", SCREEN_SIZE, SCREEN_SIZE).build().unwrap();
    println!("Window: {}x{} at {} px per cell", SCREEN_SIZE, SCREEN_SIZE, PX_SIZE);
    let size: usize = (SCREEN_SIZE/PX_SIZE) as usize;
    let mut grid = Grid::new(microworlds::Cell{color: microworlds::BLACK}, size);

    println!("cell grid: {}x{} ({} cells) - {} steps per sec", size, size, (size*size), STEPS_PER_SEC);

    let mut engine = microworlds::life::new(size);

    // Let's create a Canvas which we will use to draw in our Window
    let canvas : Canvas<Window> = window.into_canvas()
        .present_vsync() //< this means the screen cannot
        // render faster than your display rate (usually 60Hz or 144Hz)
        .build().unwrap();

    let mut renderer= microworlds::Renderer::new( PX_SIZE as i32, canvas);

    let mut frame = 0;

    let mut event_pump = sdl_context.event_pump().unwrap();

    let period = time::Duration::from_millis(1000 / STEPS_PER_SEC);
    'main: loop {
        for event in event_pump.poll_iter() {
            match event {
                sdl2::event::Event::Quit {..} => break 'main,
                _ => {},
            }
        }

        let start_rend = SystemTime::now();
        renderer.render(grid);
        let render_time = start_rend.elapsed().unwrap();
        let start_evo = SystemTime::now();
        grid = engine.evolve();
        let evo_time = start_evo.elapsed().unwrap();
        let total_time = start_rend.elapsed().unwrap();
        frame += 1;
        println!("frame: {} - render time: {:?} | evolve time: {:?} | total time: {:?}", frame, render_time, evo_time, total_time);

        if total_time < period {
            thread::sleep(period - total_time);
        }
    }
}