// Xử lý đồng bộ truyền thống
fn handle_request(request: HttpRequest) -> HttpResponse {
    let data = database.query("SELECT * FROM users"); // Truy vấn đồng bộ
    let content = fs::read_to_string("template.html"); // Đọc file đồng bộ
    HttpResponse::new(content)
}

use hyperlane::*;

async fn handle_async_request(ctx: Context) {
    let data = database.query_async("SELECT * FROM users").await;
    let content = tokio::fs::read_to_string("template.html").await;
    ctx.set_response_status_code(200).await
       .set_response_body(content).await;
}

async fn safe_memory_handling(ctx: Context) {
    let request_body: Vec<u8> = ctx.get_request_body().await;
    let socket_addr: String = ctx.get_socket_addr_or_default_string().await;
    ctx.set_response_header(SERVER, HYPERLANE).await
       .set_response_header(CONNECTION, KEEP_ALIVE).await
       .set_response_header("SocketAddr", socket_addr).await;
}

#[tokio::main]
async fn main() {
    let server: Server = Server::new();
    server.host("0.0.0.0").await;
    server.port(60000).await;
    server.enable_nodelay().await;
    server.disable_linger().await;
    server.http_buffer_size(4096).await;
    server.ws_buffer_size(4096).await;
    server.route("/", root_route).await;
    server.run().await.unwrap();
}

async fn root_route(ctx: Context) {
    ctx.set_response_status_code(200).await
       .set_response_body("Hello World").await;
}

async fn cross_platform_server() {
    let server = Server::new();
    server.host("0.0.0.0").await;
    server.port(8080).await;
    server.enable_nodelay().await;
    server.route("/file", |ctx: Context| async move {
        let file_content = tokio::fs::read("data.txt").await.unwrap();
        ctx.set_response_body(file_content).await;
    }).await;
    server.run().await.unwrap();
}

async fn high_concurrency_handler(ctx: Context) {
    let user_id = ctx.get_route_params().await.get("id").unwrap();
    let user_data = fetch_user_data(user_id).await;
    ctx.set_response_status_code(200).await
       .set_response_body(serde_json::to_string(&user_data).unwrap()).await;
}

async fn fetch_user_data(user_id: &str) -> UserData {
    tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
    UserData { id: user_id.to_string(), name: "User".to_string() }
}

async fn middleware_example(ctx: Context) {
    let start_time = std::time::Instant::now();
    ctx.set_response_header("X-Response-Time", format!("{}ms", start_time.elapsed().as_millis())).await;
}

async fn error_handler(error: PanicInfo) {
    eprintln!("Error occurred: {}", error);
    let _ = std::io::Write::flush(&mut std::io::stderr());
}

async fn benchmark_handler(ctx: Context) {
    let start = std::time::Instant::now();
    let data = process_business_logic().await;
    let duration = start.elapsed();
    ctx.set_response_header("X-Process-Time", format!("{}μs", duration.as_micros())).await
       .set_response_body(data).await;
}

async fn process_business_logic() -> String {
    tokio::time::sleep(tokio::time::Duration::from_micros(50)).await;
    "Processed data".to_string()
}