use zero_io::{Io, Config, Event};

fn main() -> std::io::Result<()> {
    let mut io = Io::new(Config::default())?;
    io.quic_listen("0.0.0.0:4433".parse()?, &CERT_PEM, &KEY_PEM)?;

    loop {
        io.poll(Duration::from_millis(10))?;
        while let Some(event) = io.next_event() {
            match event {
                Event::StreamFrame { conn, stream, data, .. } => {
                    // `data` is &[u8] borrowed from a pool slot
                    // invalidated on the next poll() — process now or detach
                    io.stream_write(conn, stream, data)?;
                }
                _ => {}
            }
        }
    }
}

// Before: tokio + hyper
let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await?;
axum::serve(listener, app).await?;

// After: zero-io. Two lines changed. Same axum router.
let mut io = Io::new(Config::default())?;
io.http_listen("0.0.0.0:8080".parse()?)?;
zero_io_axum::serve(io, app)?.wait()?;

// 64 B / req. Generic Tower + zero-io native middleware. 0 alloc per layer.
use tower::ServiceBuilder;
use zero_io_async::{ZeroRuntime, ZeroCorsLayer, ZeroTraceLayer, ZeroCompressionLayer};

let svc = ServiceBuilder::new()
    .layer(ZeroTraceLayer::new())
    .layer(ZeroCorsLayer::permissive())
    .layer(ZeroCompressionLayer::zstd())
    .layer(tower::timeout::TimeoutLayer::new(Duration::from_secs(10)))
    .service(my_handler);

ZeroRuntime::new(io).run_tower(svc)?.wait()?;

use zero_io::{Io, Config, Event, StreamId};

fn main() -> std::io::Result<()> {
    let mut io = Io::new(Config::default())?;
    let conn = io.quic_connect("203.0.113.1:4433".parse()?)?;

    loop {
        io.poll(Duration::from_millis(10))?;
        while let Some(event) = io.next_event() {
            match event {
                Event::Connected { .. } => {
                    // 1-RTT ready · session ticket cached for next 0-RTT
                    io.stream_write(conn, StreamId(0), b"GET /quote HTTP/3\n")?;
                }
                Event::StreamFrame { data, .. } => {
                    // `data` borrows the same pool slot the NIC DMA'd into
                    process(data);
                }
                _ => {}
            }
        }
    }
}

// 0 allocs/req on warm pool · LIFO connection reuse · TFO + Happy Eyeballs +
// TLS 0-RTT + Alt-Svc h3 auto-upgrade — all transparent.
use zero_io::http_client::{HttpClient, HttpClientConfig};

// Async wrapper: drop-in replacement for reqwest at ~10× the throughput.
#[tokio::main]
async fn main() -> std::io::Result<()> {
    let client = HttpClient::new(HttpClientConfig::default())?;

    let resp = client
        .get("https://api.example.com/users/42")
        .header("authorization", "Bearer …")
        .send().await?;

    match resp.status() {
        200 => println!("{}", resp.text()?),
        s   => eprintln!("http {}", s),
    }
    Ok(())
}

// 100 SET + 100 GET in one round-trip via writev. RESP3 inline.
use zero_io::redis::{RedisClient, RedisConfig};

let mut io = Io::new(Config::default())?;
let client = RedisClient::connect(&mut io, RedisConfig::localhost())?;

let mut pipe = client.pipeline();
for i in 0..100 {
    pipe.set(&format!("k:{}", i), format!("v:{}", i).as_bytes());
}
let results = pipe.exec(&mut io)?; // 1 round-trip, not 100