// Phương thức xử lý đồng bộ truyền thống
fn handle_request(request: HttpRequest) -> HttpResponse {
    // Truy vấn cơ sở dữ liệu chặn
    let data = database.query("SELECT * FROM users");
    // Đọc file chặn
    let content = fs::read_to_string("template.html");
    // Xử lý và trả về phản hồi
    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();

    // Logic xử lý request

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