fn handle_request(request: HttpRequest) -> HttpResponse {
  // Truy vấn DB đồng bộ
  let data = database.query("SELECT * FROM users");
  // Đọc file đồng bộ
  let content = fs::read_to_string("template.html");
  // Trả về response
  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();
  // 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());
}