//! Core operation benchmarks
//!
//! Measures the fundamental performance of basic announcement operations:
//! - Channel creation overhead
//! - Listener creation cost
//! - Announcement without listeners
//! - Try-listen operations (hit and miss cases)
//! - Status check operations

use announcement::Announcement;
use criterion::{criterion_group, criterion_main, Criterion};
use std::hint::black_box;

/// Benchmark: Create a new announcement channel
fn bench_channel_creation(c: &mut Criterion) {
    c.bench_function("core/channel_creation", |b| {
        b.iter(|| {
            let (_tx, _announcement) = Announcement::<i32>::new();
        });
    });
}

/// Benchmark: Create a listener from an existing announcement
fn bench_listener_creation(c: &mut Criterion) {
    let (_tx, announcement) = Announcement::<i32>::new();

    c.bench_function("core/listener_creation", |b| {
        b.iter(|| black_box(announcement.listener()));
    });
}

/// Benchmark: Announce with no listeners attached
fn bench_announce_no_listeners(c: &mut Criterion) {
    c.bench_function("core/announce_no_listeners", |b| {
        b.iter(|| {
            let (tx, _) = Announcement::<i32>::new();
            tx.announce(black_box(42)).unwrap();
        });
    });
}

/// Benchmark: try_listen when value is available (cache hit)
fn bench_try_listen_hit(c: &mut Criterion) {
    let (tx, announcement) = Announcement::new();
    tx.announce(42).unwrap();
    let listener = announcement.listener();

    c.bench_function("core/try_listen_hit", |b| {
        b.iter(|| {
            black_box(listener.try_listen());
        });
    });
}

/// Benchmark: try_listen when no value available (cache miss)
fn bench_try_listen_miss(c: &mut Criterion) {
    let (_tx, announcement) = Announcement::<i32>::new();
    let listener = announcement.listener();

    c.bench_function("core/try_listen_miss", |b| {
        b.iter(|| {
            black_box(listener.try_listen());
        });
    });
}

/// Benchmark: Check is_announced status
fn bench_is_announced(c: &mut Criterion) {
    let mut group = c.benchmark_group("core/is_announced");

    // Not yet announced
    let (_tx_not, announcement_not) = Announcement::<i32>::new();
    group.bench_function("before_announce", |b| {
        b.iter(|| {
            black_box(announcement_not.is_announced());
        });
    });

    // Already announced
    let (tx, announcement_yes) = Announcement::<i32>::new();
    let _result = tx.announce(42);
    group.bench_function("after_announce", |b| {
        b.iter(|| {
            black_box(announcement_yes.is_announced());
        });
    });

    group.finish();
}

/// Benchmark: Check is_closed status
fn bench_is_closed(c: &mut Criterion) {
    let mut group = c.benchmark_group("core/is_closed");

    // Not yet closed
    let (_tx, announcement) = Announcement::<i32>::new();
    group.bench_function("announcer_alive", |b| {
        b.iter(|| {
            black_box(announcement.is_closed());
        });
    });

    // After dropping announcer
    let announcement_closed = {
        let (tx, announcement) = Announcement::<i32>::new();
        drop(tx);
        announcement
    };
    group.bench_function("announcer_dropped", |b| {
        b.iter(|| {
            black_box(announcement_closed.is_closed());
        });
    });

    group.finish();
}

criterion_group!(
    benches,
    bench_channel_creation,
    bench_listener_creation,
    bench_announce_no_listeners,
    bench_try_listen_hit,
    bench_try_listen_miss,
    bench_is_announced,
    bench_is_closed,
);
criterion_main!(benches);