#![feature(test)]

extern crate postscript;
extern crate random;
extern crate test;

#[macro_use]
mod support;

mod encoding {
    use postscript::compact1::Encoding;
    use random::Source;
    use test::{black_box, Bencher};

    #[bench]
    fn get(bencher: &mut Bencher) {
        let mut source = random::default().seed([42, 69]);
        let codes = source
            .iter::<u64>()
            .take(1000)
            .map(|number| (number as u16) % 256)
            .collect::<Vec<_>>();
        let encoding = Encoding::Standard;
        bencher.iter(|| {
            for &code in &codes {
                black_box(encoding.get(code));
            }
        });
    }
}

mod operation {
    use postscript::compact1::Operator;
    use random::Source;
    use test::{black_box, Bencher};

    #[bench]
    fn operator_default(bencher: &mut Bencher) {
        let mut source = random::default().seed([69, 42]);
        let operators = generate_operators(&mut source, 1000);
        bencher.iter(|| {
            for &operator in &operators {
                black_box(operator.default());
            }
        });
    }

    #[bench]
    fn operator_get(bencher: &mut Bencher) {
        let mut source = random::default().seed([42, 69]);
        let codes = generate_codes(&mut source, 1000);
        bencher.iter(|| {
            for &code in &codes {
                black_box(ok!(Operator::from(code)));
            }
        });
    }

    fn generate_codes<T: Source>(source: &mut T, count: usize) -> Vec<u16> {
        let mut codes = vec![];
        while codes.len() != count {
            if (source.read::<u64>() as i64) > 0 {
                loop {
                    let number = source.read::<u64>();
                    match (number % (0x15 + 1)) as u16 {
                        0x0c => continue,
                        code => codes.push(code),
                    }
                    break;
                }
            } else {
                loop {
                    let number = source.read::<u64>();
                    match 0x0c00 | (number % (0x26 + 1)) as u16 {
                        0x0c0f..=0x0c10 | 0x0c18..=0x0c1d => continue,
                        code => codes.push(code),
                    }
                    break;
                }
            }
        }
        codes
    }

    fn generate_operators<T: Source>(source: &mut T, count: usize) -> Vec<Operator> {
        generate_codes(source, count)
            .iter()
            .map(|&code| ok!(Operator::from(code)))
            .collect()
    }
}

mod noto_sans {
    use test::Bencher;

    use crate::support::{setup_font_set, Fixture};

    #[bench]
    fn font_set(bencher: &mut Bencher) {
        bencher.iter(|| {
            setup_font_set(Fixture::NotoSansJP);
        });
    }
}