//! Benchmarks for core operations.
//!
//! Run with: cargo bench

use std::net::SocketAddr;
use tesseras_dht::crypto::Identity;
use tesseras_dht::id::NodeId;
use tesseras_dht::peers::PeerInfo;
use tesseras_dht::routing::RoutingTable;
use tesseras_dht::wire::MsgHeader;

fn main() {
    println!("=== tesseras-dht benchmarks ===\n");

    bench_sha256();
    bench_ed25519_sign();
    bench_ed25519_verify();
    bench_routing_add();
    bench_routing_closest();
    bench_header_roundtrip();
    bench_node_id_xor();
}

fn bench_sha256() {
    let data = vec![0xABu8; 1024];
    let start = std::time::Instant::now();
    let iters = 100_000;
    for _ in 0..iters {
        let _ = NodeId::from_key(&data);
    }
    let elapsed = start.elapsed();
    println!(
        "SHA-256 (1KB):    {:>8.0} ns/op ({iters} iters)",
        elapsed.as_nanos() as f64 / iters as f64
    );
}

fn bench_ed25519_sign() {
    let id = Identity::generate();
    let data = vec![0x42u8; 256];
    let start = std::time::Instant::now();
    let iters = 10_000;
    for _ in 0..iters {
        let _ = id.sign(&data);
    }
    let elapsed = start.elapsed();
    println!(
        "Ed25519 sign:     {:>8.0} ns/op ({iters} iters)",
        elapsed.as_nanos() as f64 / iters as f64
    );
}

fn bench_ed25519_verify() {
    let id = Identity::generate();
    let data = vec![0x42u8; 256];
    let sig = id.sign(&data);
    let start = std::time::Instant::now();
    let iters = 10_000;
    for _ in 0..iters {
        let _ = Identity::verify(id.public_key(), &data, &sig);
    }
    let elapsed = start.elapsed();
    println!(
        "Ed25519 verify:   {:>8.0} ns/op ({iters} iters)",
        elapsed.as_nanos() as f64 / iters as f64
    );
}

fn bench_routing_add() {
    let local = NodeId::random();
    let mut rt = RoutingTable::new(local);
    let start = std::time::Instant::now();
    let iters = 10_000;
    for i in 0..iters {
        let id = NodeId::random();
        let addr = SocketAddr::from(([10, 0, (i % 256) as u8, 1], 3000));
        rt.add(PeerInfo::new(id, addr));
    }
    let elapsed = start.elapsed();
    println!(
        "Routing add:      {:>8.0} ns/op ({iters} iters, size={})",
        elapsed.as_nanos() as f64 / iters as f64,
        rt.size()
    );
}

fn bench_routing_closest() {
    let local = NodeId::random();
    let mut rt = RoutingTable::new(local);
    for i in 0..500 {
        let id = NodeId::random();
        let addr = SocketAddr::from(([10, 0, (i % 256) as u8, 1], 3000));
        rt.add(PeerInfo::new(id, addr));
    }

    let target = NodeId::random();
    let start = std::time::Instant::now();
    let iters = 10_000;
    for _ in 0..iters {
        let _ = rt.closest(&target, 10);
    }
    let elapsed = start.elapsed();
    println!(
        "Routing closest:  {:>8.0} ns/op ({iters} iters, size={})",
        elapsed.as_nanos() as f64 / iters as f64,
        rt.size()
    );
}

fn bench_header_roundtrip() {
    let hdr = MsgHeader::new(
        tesseras_dht::wire::MsgType::DhtPing,
        100,
        NodeId::random(),
        NodeId::random(),
    );
    let mut buf = vec![0u8; tesseras_dht::wire::HEADER_SIZE];
    let start = std::time::Instant::now();
    let iters = 1_000_000;
    for _ in 0..iters {
        hdr.write(&mut buf).unwrap();
        let _ = MsgHeader::parse(&buf).unwrap();
    }
    let elapsed = start.elapsed();
    println!(
        "Header roundtrip: {:>8.0} ns/op ({iters} iters)",
        elapsed.as_nanos() as f64 / iters as f64
    );
}

fn bench_node_id_xor() {
    let a = NodeId::random();
    let b = NodeId::random();
    let start = std::time::Instant::now();
    let iters = 10_000_000;
    for _ in 0..iters {
        let _ = a.distance(&b);
    }
    let elapsed = start.elapsed();
    println!(
        "NodeId XOR:       {:>8.0} ns/op ({iters} iters)",
        elapsed.as_nanos() as f64 / iters as f64
    );
}