// Phương pháp xử lý đồng bộ truyền thống
fn handle_request(request: HttpRequest) -> HttpResponse {
    // Truy vấn cơ sở dữ liệu đồng bộ, chặn luồng
    let data = database.query("SELECT * FROM users");
    // Đọc file mẫu đồng bộ
    let content = fs::read_to_string("template.html");
    // Trả về phản hồi
    HttpResponse::new(content)
}

use hyperlane::*;

async fn handle_async_request(ctx: Context) {
    // Truy vấn cơ sở dữ liệu không chặn
    let data = database.query_async("SELECT * FROM users").await;
    // Đọc file không chặn
    let content = tokio::fs::read_to_string("template.html").await;
    // Thiết lập phản hồi HTTP
    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;
}

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();
    // Xử lý logic request
    ctx.set_response_header("X-Response-Time", format!("{}ms", start_time.elapsed().as_millis()))
       .await;
}

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()
}