capnweb-server 0.1.0

use crate::Server;
use quinn::{Endpoint, ServerConfig as QuinnServerConfig};
use std::net::SocketAddr;
use std::sync::Arc;
use tracing::info;

/// HTTP/3 server for Cap'n Web protocol
pub struct H3Server {
    #[allow(dead_code)]
    server: Arc<Server>,
    endpoint: Option<Endpoint>,
}

impl H3Server {
    /// Create a new HTTP/3 server
    pub fn new(server: Arc<Server>) -> Self {
        Self {
            server,
            endpoint: None,
        }
    }

    /// Start the HTTP/3 server on the specified address
    pub async fn listen(&mut self, addr: SocketAddr) -> Result<(), Box<dyn std::error::Error>> {
        // Create server configuration with self-signed certificate for testing
        let server_config = configure_server()?;

        // Create endpoint
        let endpoint = Endpoint::server(server_config, addr)?;
        info!("HTTP/3 server listening on {}", addr);

        self.endpoint = Some(endpoint.clone());

        // For now, just accept connections without processing
        // Full H3 implementation would require more complex stream handling
        while let Some(_incoming) = endpoint.accept().await {
            // TODO: Implement H3 request handling when API stabilizes
        }

        Ok(())
    }

    /// Shutdown the server
    pub fn shutdown(&mut self) {
        if let Some(endpoint) = &self.endpoint {
            endpoint.close(0u32.into(), b"server shutdown");
        }
    }
}

/// Configure server with self-signed certificate for testing
fn configure_server() -> Result<QuinnServerConfig, Box<dyn std::error::Error>> {
    let rcgen::CertifiedKey { cert, signing_key } =
        rcgen::generate_simple_self_signed(vec!["localhost".into()])?;
    let cert_der = rustls::pki_types::CertificateDer::from(cert.der().to_vec());
    let priv_key = rustls::pki_types::PrivateKeyDer::try_from(signing_key.serialize_der())?;

    let cert_chain = vec![cert_der];

    let mut server_config = rustls::ServerConfig::builder()
        .with_no_client_auth()
        .with_single_cert(cert_chain, priv_key)?;

    server_config.alpn_protocols = vec![b"h3".to_vec()];

    let server_config = QuinnServerConfig::with_crypto(Arc::new(
        quinn::crypto::rustls::QuicServerConfig::try_from(server_config)?,
    ));

    Ok(server_config)
}

#[cfg(test)]
mod tests {
    #[test]
    fn test_h3_server_creation() {
        // Basic test to ensure the module compiles
        // Full integration tests would require running server
    }
}