use flux::disruptor::{RingBuffer, RingBufferConfig, WaitStrategyType};

// Create a ring buffer with 1M slots and 1 consumer
let config = RingBufferConfig::new(1024 * 1024)
    .unwrap()
    .with_consumers(1)
    .unwrap()
    .with_wait_strategy(WaitStrategyType::BusySpin);

let buffer = RingBuffer::new(config).unwrap();

// Producer: claim and publish a batch
if let Some((seq, slots)) = buffer.try_claim_slots(10) {
    for (i, slot) in slots.iter_mut().enumerate() {
        slot.set_sequence(seq + i as u64);
        slot.set_data(b"Hello, Flux!");
    }
    buffer.publish_batch(seq, slots.len());
}

// Consumer: read a batch
let messages = buffer.try_consume_batch(0, 10);
for message in messages {
    println!("Received: {:?}", message.data());
}

use flux::disruptor::{RingBufferConfig, ring_buffer::MappedRingBuffer};

let config = RingBufferConfig::new(1024 * 1024)
    .unwrap()
    .with_consumers(4)
    .unwrap()
    .with_optimal_batch_size(8192);

let buffer = MappedRingBuffer::new_mapped(config).unwrap();

// Producer: claim a large batch for high throughput
if let Some((seq, slots)) = buffer.try_claim_slots(8192) {
    for (i, slot) in slots.iter_mut().enumerate() {
        slot.set_sequence(seq + i as u64);
        // Use SIMD-optimized data copy for best performance
        slot.set_data(b"Ultra-fast message");
    }
    buffer.publish_batch(seq, slots.len());
}

use flux::{BasicUdpTransport, BasicUdpConfig};

// Configure basic UDP transport
let config = BasicUdpConfig {
    local_addr: "0.0.0.0:8080".to_string(),
    buffer_size: 4096,
    batch_size: 64,
    non_blocking: true,
    socket_timeout_ms: 100,
};

let mut transport = BasicUdpTransport::new(config)?;
transport.start()?;

// Send messages
transport.send(b"Hello, Flux!", addr)?;

// Receive messages
if let Some((data, _addr)) = transport.receive()? {
    println!("Received: {:?}", data);
}

use flux::transport::zero_copy_udp::{ZeroCopyUdpTransport, ZeroCopyConfig};

// Configure for high-performance UDP
let config = ZeroCopyConfig {
    batch_size: 1000,
    buffer_size: 1024 * 1024,
    socket_buffer_mb: 64,
    busy_poll: true,
    ..Default::default()
};

let transport = ZeroCopyUdpTransport::new(config)?;
transport.start()?;

// Send high-throughput batches
let messages = vec![b"Hello"; 1000];
transport.send_batch(&messages.iter().map(|m| m.as_slice()).collect::<Vec<_>>(), addr)?;

use flux::transport::{ReliableUdpTransport, TransportConfig};

let config = TransportConfig {
    batch_size: 64,
    buffer_size: 1024 * 1024,
    retransmit_timeout_ms: 100,
    max_retransmits: 3,
    enable_fec: true,  // Forward Error Correction
    ..Default::default()
};

let mut transport = ReliableUdpTransport::new(config)?;
transport.start()?;

// Send with automatic retransmission and FEC
transport.send(b"Reliable message", addr)?;

// Receive with guaranteed delivery
if let Some((data, _addr)) = transport.receive()? {
    println!("Received: {:?}", data);
}