use hyperlane::*;

async fn memory_safe_handler(ctx: Context) {
    let request_body: Vec<u8> = ctx.get_request_body().await;
    let processed_data: String = String::from_utf8_lossy(&request_body).to_string();
    ctx.set_response_status_code(200)
       .await
       .set_response_body(processed_data)
       .await;
}

async fn concurrent_handler(ctx: Context) {
  let socket_addr: String = ctx.get_socket_addr_or_default_string().await;
  ctx.set_response_header(CONNECTION, KEEP_ALIVE)
    .await
    .set_response_header("Client-Address", socket_addr)
    .await;
}

async fn zero_copy_stream(ctx: Context) {
  let request_body: Vec<u8> = ctx.get_request_body().await;
  let _ = ctx.set_response_body(request_body).await.send_body().await;
}

async fn shared_state_handler(ctx: Context) {
  let local_data: String = format!("Request from: {}", ctx.get_socket_addr_or_default_string().await);
  ctx.set_response_body(local_data).await;
}

async fn middleware_safety(ctx: Context) {
  ctx.set_response_header(CONTENT_TYPE, TEXT_PLAIN).await
     .set_response_header(SERVER, HYPERLANE).await;
}

async fn leak_proof_handler(ctx: Context) {
  {
    let large_buffer: Vec<u8> = vec![0; 1024 * 1024];
    let processed: String = String::from_utf8_lossy(&large_buffer).to_string();
    ctx.set_response_body(processed).await;
  }
  // large_buffer đã được giải phóng tự động tại đây.
}

async fn profiled_handler(ctx: Context) {
  let start_time = std::time::Instant::now();
  let request_body: Vec<u8> = ctx.get_request_body().await;
  let response_data: String = process_data(&request_body);
  let duration = start_time.elapsed();
  ctx.set_response_header("Processing-Time", format!("{:?}", duration)).await
     .set_response_body(response_data).await;
}

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