use hyperlane::*;

async fn ultra_low_latency_handler(ctx: Context) {
  // Truy cập bộ nhớ trực tiếp, không cấp phát trung gian
  let request_body: Vec<u8> = ctx.get_request_body().await;

  // Phản hồi ngay lập tức, không chờ đệm
  ctx.set_response_status_code(200)
     .await
     .set_response_body("OK")
     .await;
}

async fn optimized_middleware(ctx: Context) {
  // Xử lý header tối giản để tăng tốc độ
  ctx.set_response_header(CONNECTION, KEEP_ALIVE)
     .await
     .set_response_header(CONTENT_TYPE, TEXT_PLAIN)
     .await;
}

#[tokio::main]
async fn main() {
  let server: Server = Server::new();
  server.host("0.0.0.0").await;
  server.port(60000).await;

  // Tối ưu TCP quan trọng
  server.enable_nodelay().await; // Tắt Nagle's algorithm
  server.disable_linger().await; // Tắt linger để dọn dẹp kết nối ngay
  server.http_buffer_size(4096).await; // Kích thước buffer tối ưu
  server.ws_buffer_size(4096).await;
  server.request_middleware(optimized_middleware).await;
  server.route("/fast", ultra_low_latency_handler).await;
  server.run().await.unwrap();
}

async fn tcp_optimized_server() {
  let server: Server = Server::new();
  server.enable_nodelay().await;
  server.disable_linger().await;
  server.http_buffer_size(4096).await;
  server.run().await.unwrap();
}

async fn zero_allocation_handler(ctx: Context) {
  const RESPONSE: &str = "Fast response";
  ctx.set_response_status_code(200).await
     .set_response_body(RESPONSE).await;
}

async fn efficient_parameter_handling(ctx: Context) {
  let params: RouteParams = ctx.get_route_params().await;
  if let Some(id) = ctx.get_route_param("id").await {
    // Tham chiếu dữ liệu nguyên gốc, không cấp phát
    ctx.set_response_body(format!("ID: {}", id)).await;
  }
}

async fn pre_computed_response_handler(ctx: Context) {
  static CACHED_RESPONSE: &str = "Cached result";
  ctx.set_response_status_code(200).await
     .set_response_body(CACHED_RESPONSE).await;
}

async fn streaming_response_handler(ctx: Context) {
  ctx.set_response_status_code(200).await.send().await;
  for chunk in ["chunk1", "chunk2", "chunk3"] {
    let _ = ctx.set_response_body(chunk).await.send_body().await;
  }
  let _ = ctx.closed().await;
}

async fn monitored_handler(ctx: Context) {
  let start_time = std::time::Instant::now();

  let request_body: Vec<u8> = ctx.get_request_body().await;
  let response = process_request(&request_body);

  let processing_time = start_time.elapsed();
  ctx.set_response_header("X-Processing-Time", format!("{:.3}ms", processing_time.as_secs_f64() * 1000.0))
     .await
     .set_response_body(response)
     .await;
}

fn process_request(data: &[u8]) -> String {
  String::from_utf8_lossy(data).to_string()
}

async fn keep_alive_middleware(ctx: Context) {
  ctx.set_response_header(CONNECTION, KEEP_ALIVE)
     .await
     .set_response_header("Keep-Alive", "timeout=60, max=1000")
     .await;
}