use std::time::Instant;
#[macro_use] extern crate lazy_static;

mod util;
mod day1;
mod day2;
mod day3;
mod day4;
mod day5;
mod day6;
mod day7;
mod day8;
mod day9;
mod day10;
mod day11;

const MAX_DAY: u8 = 11;
const BENCHMARK_AMOUNT: u32 = 100;

fn solve(day: u8) {
    match day {
        1 => day1::solve(),
        2 => day2::solve(),
        3 => day3::solve(),
        4 => day4::solve(),
        5 => day5::solve(),
        6 => day6::solve(),
        7 => day7::solve(),
        8 => day8::solve(),
        9 => day9::solve(),
        10 => day10::solve(),
        11 => day11::solve(),
        _ => println!("This day is not yet implemented")
    }
}

fn main() {


    let args: Vec<String> = std::env::args().collect();

    let day_arg_idx = args.iter().position(|a| a == "-d");
    let single_day = day_arg_idx.is_some();
    let day = if single_day { args[day_arg_idx.unwrap() + 1].parse::<u8>().unwrap() } else { 0 };

    let benchmark = args.contains(&String::from("--bench")) || args.contains(&String::from("-b"));

    let mut bench_results: Vec<u128> = Vec::new();

    // This is essentially the warmup for the benchmark:
    run_once(single_day, day, &mut bench_results);

    if benchmark {
        for _ in 0..BENCHMARK_AMOUNT {
            run_once(single_day, day, &mut bench_results);
        }
    }

    let avg_runtime: u128 = bench_results.iter().sum::<u128>() / (bench_results.len() as u128);

    println!("Execution took {} μs {}", avg_runtime, if benchmark { "on average" } else { "" });
}

fn run_once(single_day: bool, day: u8, bench_results: &mut Vec<u128>) {

    let now  = Instant::now();
    if single_day {
        solve(day);
    } else {
        solve_all();
    }
    bench_results.push(now.elapsed().as_micros());
}

fn solve_all() {
    for day in 1..(MAX_DAY + 1) {
        solve(day);
    }
}