use core::panic;
use std::path::Path;

use criterion::{criterion_group, criterion_main, Criterion};

fn prefix_linear(a: &str, b: &str, res: usize) {
    let found = a.bytes().zip(b.bytes()).take_while(|(a, b)| a == b).count();

    if found != res {
        panic!()
    }
}

fn prefix_binary(a: &str, b: &str, res: usize) {
    let a = a.as_bytes();
    let b = b.as_bytes();

    let mut pointmin = 0;
    let mut pointmax = a.len().min(b.len());
    let mut pointmid = pointmax;

    let mut pointstart = 0;

    while pointmin < pointmid {
        if a[pointstart..pointmid] == b[pointstart..pointmid] {
            pointmin = pointmid;
            pointstart = pointmin;
        } else {
            pointmax = pointmid;
        }

        pointmid = (pointmax - pointmin) / 2 + pointmin;
    }

    if pointmid != res {
        panic!("Not desired res")
    }
}

fn create_data() -> Vec<(String, String, usize, usize)> {
    let basedir = Path::new("testdata");
    let data = [100, 1000, 10000, 100000, 1000000, 10000000]
        .iter()
        .map(|&n| {
            let old = std::fs::read_to_string(basedir.join(format!("old_{n}.txt"))).unwrap();
            let new = std::fs::read_to_string(basedir.join(format!("new_{n}.txt"))).unwrap();

            let res = std::fs::read_to_string(basedir.join(format!("ans_{n}.txt")))
                .unwrap()
                .parse::<usize>()
                .unwrap();

            (old, new, res, n)
        })
        .collect();

    data
}

pub fn prefix_bench(c: &mut Criterion) {
    let d = create_data();

    for (old, new, res, n) in d.iter() {
        println!("For N={n}");
        c.bench_function("prefix linear", |bencher| {
            bencher.iter(|| prefix_linear(old, new, *res))
        });
        c.bench_function("prefix binary", |bencher| {
            bencher.iter(|| prefix_binary(old, new, *res))
        });
    }
}

criterion_group!(prefix, prefix_bench);
criterion_main!(prefix);