//! Benchmarks for validation operations

use atproto_plc::{Did, DidBuilder, OperationChainValidator, SigningKey};
use criterion::{black_box, criterion_group, criterion_main, Criterion};

fn benchmark_did_validation(c: &mut Criterion) {
    c.bench_function("valid did parse", |b| {
        b.iter(|| Did::parse(black_box("did:plc:ewvi7nxzyoun6zhxrhs64oiz")))
    });

    c.bench_function("invalid did parse", |b| {
        b.iter(|| Did::parse(black_box("did:plc:invalid")))
    });
}

fn benchmark_key_generation(c: &mut Criterion) {
    c.bench_function("p256 keygen", |b| {
        b.iter(|| SigningKey::generate_p256())
    });

    c.bench_function("k256 keygen", |b| {
        b.iter(|| SigningKey::generate_k256())
    });
}

fn benchmark_did_creation(c: &mut Criterion) {
    c.bench_function("create did with builder", |b| {
        b.iter(|| {
            let rotation_key = SigningKey::generate_p256();
            let signing_key = SigningKey::generate_k256();

            DidBuilder::new()
                .add_rotation_key(rotation_key)
                .add_verification_method("atproto".into(), signing_key)
                .build()
        })
    });
}

fn benchmark_signature_operations(c: &mut Criterion) {
    let key = SigningKey::generate_p256();
    let data = b"hello world";

    c.bench_function("sign with p256", |b| {
        b.iter(|| key.sign(black_box(data)))
    });

    let signature = key.sign(data).unwrap();
    let verifying_key = key.verifying_key();

    c.bench_function("verify signature", |b| {
        b.iter(|| verifying_key.verify(black_box(data), black_box(&signature)))
    });
}

fn benchmark_operation_chain_validation(c: &mut Criterion) {
    // Create a simple chain
    let rotation_key = SigningKey::generate_p256();
    let (_, operation, _) = DidBuilder::new()
        .add_rotation_key(rotation_key)
        .build()
        .unwrap();

    c.bench_function("validate single operation chain", |b| {
        b.iter(|| OperationChainValidator::validate_chain(black_box(&[operation.clone()])))
    });
}

fn benchmark_did_key_conversion(c: &mut Criterion) {
    let key = SigningKey::generate_p256();
    let did_key = key.to_did_key();

    c.bench_function("to did:key", |b| {
        b.iter(|| key.to_did_key())
    });

    c.bench_function("from did:key", |b| {
        b.iter(|| atproto_plc::VerifyingKey::from_did_key(black_box(&did_key)))
    });
}

criterion_group!(
    benches,
    benchmark_did_validation,
    benchmark_key_generation,
    benchmark_did_creation,
    benchmark_signature_operations,
    benchmark_operation_chain_validation,
    benchmark_did_key_conversion
);
criterion_main!(benches);