use clap::{App, Arg};

pub const SCREEN_SIZE_DEFAULT: u32 = 800;
pub const PX_SIZE_DEFAULT: u32 = 2;
pub const STEPS_PER_SEC_DEFAULT: u64 = 8;


fn main() {
    let matches = App::new("microworlds")
        .version("0.1")
        .arg(Arg::with_name("engine")
            .long("--engine")
            .short("-e")
            .help("select the engine to run")
            .possible_values(&["life", "simple"])
            .takes_value(true)
            .required(true))
        .arg(Arg::with_name("size")
            .long("--size")
            .help("dimension of square in number of patches")
            .takes_value(true)
            .default_value("800"))
        .arg(Arg::with_name("pixels")
            .long("--pixels")
            .takes_value(true)
            .help("pixels per patch")
            .default_value("2"))
        .arg(Arg::with_name("steps")
            .long("--steps")
            .help("steps per second to max out at")
            .takes_value(true)
            .default_value("8"))
        .get_matches();


    let px_size = match matches.value_of("pixels") {
        Some(arg) => arg.parse().expect("pixels requires a number"),
        None => PX_SIZE_DEFAULT,
    };

    let num_patches: u32 = match matches.value_of("size") {
        Some(arg) => arg.parse().expect("size requires a number"),
        None => SCREEN_SIZE_DEFAULT,
    };

    let steps = match matches.value_of("steps") {
        Some(arg) => arg.parse().expect("steps requires a number"),
        None => STEPS_PER_SEC_DEFAULT,
    };

    let size: usize = (num_patches/px_size) as usize;
    let engine;

    match matches.value_of("engine") {
        Some(arg) => match arg {
            "life" => engine = microworlds::life::new(size),
            _ => {
                println!("Invalud engine selected: {}", arg);
                return;
            }
        },
        None => {
            println!("Engine selection requires");
            return;
        }
    }

    let mut observer= microworlds::Observer::new(px_size as i32, num_patches);
    println!("cell grid: {}x{} ({} cells) - {} steps per sec", size, size, (size*size), steps);
    observer.sim(engine, steps);
}