#[derive(EnumString, Display, PartialEq)]

pub fn benchmark(output_path: impl AsRef<Path>, rewriter: Rewriter) -> Result<(), Box<dyn Error>> {

    let cwd = env::current_dir()?;

    let mcrl2_rewrite_path = if rewriter == Rewriter::Innermost || rewriter == Rewriter::Sabre {

        cmd!("cargo", "build", "--profile", "bench", "--bin", "mcrl2rewrite").run()?;

        which::which_in("mcrl2rewrite", Some("target/release/"), cwd)?

        which::which("mcrl2rewrite")?

    let mcrl2_rewrite_timing = match rewriter {

        Rewriter::Innermost => Regex::new(r#"Innermost rewrite took ([0-9]*) ms"#)?,

        Rewriter::Sabre => Regex::new(r#"Sabre rewrite took ([0-9]*) ms"#)?,

        Rewriter::Jitty | Rewriter::JittyCompiling => Regex::new(r#"rewriting: ([0-9]*) milliseconds."#)?,

    if let Some(parent) = output_path.as_ref().parent() {

        fs::create_dir_all(parent)?;

    }

    let mut result_file = File::create(output_path)?;

    for file in fs::read_dir("examples/REC/mcrl2")? {

        let path = file?.path();

        // We take the dataspec file, and append the expressions ourselves.

        if path.extension().is_some_and(|ext| ext == "dataspec") {

            let data_spec = path.clone();

            let expressions = path.with_extension("expressions");

            let benchmark_name = path.file_stem().unwrap().to_string_lossy();

            println!("Benchmarking {}", benchmark_name);

            let mut arguments = vec!["600".to_string(), mcrl2_rewrite_path.to_string_lossy().to_string()];

            match rewriter {

                Rewriter::Innermost => {

                    arguments.push("rewrite".to_string());

                    arguments.push("innermost".to_string());

                }

                Rewriter::Sabre => {

                    arguments.push("rewrite".to_string());

                    arguments.push("sabre".to_string());

                }

                Rewriter::Jitty => {

                    arguments.push("-rjitty".to_string());

                    arguments.push("--timings".to_string());

                }

                Rewriter::JittyCompiling => {

                    arguments.push("-rjittyc".to_string());

                    arguments.push("--timings".to_string());

                }

            arguments.push(data_spec.to_string_lossy().to_string());

            arguments.push(expressions.to_string_lossy().to_string());

            let mut measurements = MeasurementEntry {

                rewriter: rewriter.to_string(),

                benchmark_name: benchmark_name.to_string(),

                timings: Vec::new(),

            };

            for _ in 0..5 {

                match cmd("timeout", &arguments).stdout_capture().stderr_capture().run() {

                    Ok(result) => {

                        for line in result.stdout.lines().chain(result.stderr.lines()) {

                            let line = line?;

                            if let Some(result) = mcrl2_rewrite_timing.captures(&line) {

                                let (_, [grp1]) = result.extract();

                                let timing: f32 = grp1.parse()?;

                                println!("Benchmark {} timing {} milliseconds", benchmark_name, timing);

                                // Write the output to the file and include a newline.

                                measurements.timings.push(timing / 1000.0);

                            }

                    Err(err) => {

                        println!("Benchmark {} timed out or crashed", benchmark_name);

                        println!("Command failed {:?}", err);

                        break;

            serde_json::to_writer(&mut result_file, &measurements)?;

            writeln!(&result_file)?;

        }

    Ok(())

}

fn average(values: &[f32]) -> f32 {

    values.iter().sum::<f32>() / values.len() as f32

}

fn print_float(value: f32) -> String {

    format!("{:.1}", value)

}

pub fn create_table(json_path: impl AsRef<Path>) -> Result<(), Box<dyn Error>> {

    let output = fs::read_to_string(json_path)?;

    let mut results: HashMap<String, HashMap<String, f32>> = HashMap::new();

    // Figure out the list of rewriters used to print '-' values.

    let mut rewriters: HashSet<String> = HashSet::new();

    for line in output.lines() {

        let timing = serde_json::from_str::<MeasurementEntry>(line)?;

        rewriters.insert(timing.rewriter.clone());

        results

            .entry(timing.benchmark_name)

            .and_modify(|e| {

                e.insert(timing.rewriter.clone(), average(&timing.timings));

            })

            .or_insert_with(|| {

                let mut table = HashMap::new();

                table.insert(timing.rewriter.clone(), average(&timing.timings));

                table

            });

    }

    let mut first = true;

    for rewriter in &rewriters {

        if first {

            print!("{: >30}", rewriter);

            first = false;

        } else {

            print!("{: >10} |", rewriter);

        }

    for (benchmark, result) in &results {

        print!("{: >30}", benchmark);

        for rewriter in &rewriters {

            if let Some(timing) = result.get(rewriter) {

                print!("| {: >10}", print_float(*timing));

            } else {

                print!("| {: >10}", "-");

            }

        println!();

    Ok(())

}