use commonware_cryptography::{
    Signer,
    ed25519::PrivateKey,
    handshake::sake::{Context, Error, Version, dial_end, dial_start, listen_end, listen_start},
    transcript::Transcript,
};
use commonware_math::algebra::Random;
use commonware_utils::test_rng;
use criterion::{Criterion, criterion_group};

fn connect() -> Result<(Transcript, Transcript), Error> {
    let mut rng = test_rng();
    let dialer_crypto = PrivateKey::random(&mut rng);
    let listener_crypto = PrivateKey::random(&mut rng);

    let (d_state, msg1) = dial_start(
        &mut rng,
        Context::new(
            b"bench_namespace",
            0,
            0..1,
            dialer_crypto.clone(),
            listener_crypto.public_key(),
            Version::V1,
        ),
    );
    let (l_state, msg2) = listen_start(
        &mut rng,
        Context::new(
            b"bench_namespace",
            0,
            0..1,
            listener_crypto,
            dialer_crypto.public_key(),
            Version::V1,
        ),
        msg1,
    )?;
    let (msg3, dialer) = dial_end(d_state, msg2)?;
    let listener = listen_end(l_state, msg3)?;
    Ok((dialer, listener))
}

fn bench_connect(c: &mut Criterion) {
    c.bench_function(module_path!(), |b| b.iter(|| connect().unwrap()));
}

criterion_group!(benches, bench_connect);