use arvik::{Router, get, post, Json, Path, Query, State};
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct SearchParams { q: String, page: Option<u32> }

#[derive(Deserialize)]
struct CreateUser { name: String, email: String }

#[derive(Serialize)]
struct User { id: u32, name: String }

// Path + Query extractors
async fn search(Path(id): Path<u32>, Query(params): Query<SearchParams>) -> String {
    format!("User {id} searching: {}", params.q)
}

// JSON body extractor
async fn create_user(Json(body): Json<CreateUser>) -> Json<User> {
    Json(User { id: 1, name: body.name })
}

use arvik::{Router, get, post, Json, Path};

async fn get_user(Path(id): Path<u32>) -> Json<serde_json::Value> {
    Json(serde_json::json!({ "user_id": id }))
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(|| async { "Home" }))
        .route("/users/{id}", get(get_user))
        .route("/files/{*path}", get(|| async { "File content" }));

    arvik::serve_app("0.0.0.0:8080", app).await.unwrap();
}

let api = Router::new().route("/users", get(list_users));
let admin = Router::new().route("/dashboard", get(dashboard));

let app = Router::new()
    .nest("/api/v1", api)
    .merge(admin);

use arvik::{Multipart, MultipartError};
use futures_util::StreamExt as _;

async fn upload(mut multipart: Multipart) -> Result<String, MultipartError> {
    let mut files = 0;

    while let Some(field) = multipart.next_field().await? {
        if field.file_name().is_some() {
            let temp = field.save_to_temp().await?;
            files += 1;
            println!(
                "saved {:?}: {} bytes",
                temp.metadata().file_name(),
                temp.bytes_written()
            );
        } else {
            let mut stream = field.into_progress_stream();
            while let Some(chunk) = stream.next().await {
                let chunk = chunk?;
                println!("field progress: {} bytes", chunk.bytes_read());
            }
        }
    }

    Ok(format!("received {files} files"))
}

use arvik::{middleware::map_request, MultipartConfig, Router, post};

let app = Router::new()
    .route("/upload", post(upload))
    .layer(map_request(|mut req: arvik::Request| async move {
        req.extensions_mut().insert(
            MultipartConfig::new()
                .max_fields(20)
                .max_field_size(10 * 1024 * 1024)
                .max_total_size(100 * 1024 * 1024)
                .with_temp_dir("/var/tmp/arvik-uploads"),
        );
        req
    }));

use arvik::{Router, get};
use arvik::ws::{WebSocket, WebSocketUpgrade, Message};

async fn ws_handler(ws: WebSocketUpgrade) -> impl arvik::IntoResponse {
    ws.on_upgrade(|mut socket| async move {
        // Ping/Pong handled automatically — no extra match arm needed
        while let Some(Ok(msg)) = socket.recv().await {
            match msg {
                Message::Text(text) => {
                    socket.send(Message::Text(format!("echo: {text}"))).await.ok();
                }
                Message::Binary(data) => {
                    socket.send(Message::Binary(data)).await.ok();
                }
                Message::Close(_) => break,
                _ => {}
            }
        }
    })
}

// With config + subprotocol negotiation
async fn chat_handler(ws: WebSocketUpgrade) -> impl arvik::IntoResponse {
    ws.protocols(["chat", "json"])
      .max_message_size(64 * 1024)   // 64 KB
      .max_frame_size(16 * 1024)     // 16 KB
      .on_upgrade(|socket| async move {
          let (mut sender, mut receiver) = socket.split();
          while let Some(Ok(msg)) = receiver.next().await {
              sender.send(msg).await.ok();
          }
      })
}

let app = Router::new()
    .route("/ws", get(ws_handler))
    .route("/chat", get(chat_handler));

use arvik::{Router, get};
use arvik::sse::{Event, KeepAlive, Sse};
use std::time::Duration;
use tokio_stream::StreamExt as _;

async fn json_stream() -> Sse<impl futures_util::Stream<Item = Result<Event, serde_json::Error>>> {
    let stream = tokio_stream::wrappers::IntervalStream::new(
        tokio::time::interval(Duration::from_millis(500)),
    )
    .enumerate()
    .map(|(i, _): (usize, _)| {
        Event::default()
            .event("metric")
            .id(i.to_string())
            .json_data(&serde_json::json!({ "seq": i }))
    });

    // Automatically send a `: \n\n` comment every 10 seconds to keep proxies alive
    Sse::new(stream).keep_alive(KeepAlive::new().interval(Duration::from_secs(10)))
}

let app = Router::new().route("/stream", get(json_stream));

use arvik::{Router, RustlsConfig, get, serve_tls};

async fn hello() -> &'static str {
    "secure hello"
}

let app = Router::new().route("/", get(hello));
let tls = RustlsConfig::from_pem_file("cert.pem", "key.pem").await?;
serve_tls(app, "0.0.0.0:443", tls).await?;

let tls = RustlsConfig::from_pem_file("cert.pem", "key.pem").await?;
let _watcher = tls.watch_pem_files("cert.pem", "key.pem", std::time::Duration::from_secs(1))?;

use arvik::{Router, ServerConfig, get, serve_h2c_with_config};

let app = Router::new().route("/", get(hello));
let config = ServerConfig::new()
    .http2_adaptive_window(true)
    .http2_max_concurrent_streams(1_000);

serve_h2c_with_config(app, "0.0.0.0:8080", config).await?;

use std::time::Duration;
use arvik::{RuntimeConfig, ServerConfig};

let runtime = RuntimeConfig::new()
    .worker_threads(std::thread::available_parallelism().map(usize::from).unwrap_or(1))
    .max_blocking_threads(512)
    .event_interval(61)
    .global_queue_interval(61)
    .max_io_events_per_tick(1024)
    .build()?;

let config = ServerConfig::http2_high_throughput()
    .tcp_nodelay(true)
    .tcp_keepalive(Duration::from_secs(60))
    .reuse_address(true)
    .backlog(4096)
    .socket_recv_buffer_size(512 * 1024)
    .socket_send_buffer_size(512 * 1024);

use arvik::{Router, ServeDir, ServeFile};
use std::path::PathBuf;

let assets = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("assets");
let favicon = assets.join("favicon.ico");

let app = Router::new()
    .route_service("/favicon.ico", ServeFile::new(favicon))
    .nest_service(
        "/static",
        ServeDir::new(assets)
            .precompressed_gzip()
            .precompressed_br()
            .directory_listing(true)
            .cache_control("public, max-age=60"),
    );

use arvik::{Embed, EmbeddedFileService, Router};

#[derive(Embed)]
#[folder = "assets"]
#[crate_path = "arvik"]
struct Assets;

let app = Router::new().nest_service(
    "/assets",
    EmbeddedFileService::<Assets>::new()
        .precompressed_gzip()
        .precompressed_br()
        .cache_control("public, max-age=31536000, immutable"),
);

use arvik::{Path, Router, State, debug_handler};

#[derive(Clone)]
struct AppState;

#[debug_handler(state = AppState)]
async fn echo(State(_state): State<AppState>, body: String) -> String {
    body
}

#[arvik::get("/users/{id}")]
async fn get_user(Path(id): Path<u64>) -> String {
    format!("User #{id}")
}

#[derive(Clone)]
struct Inspect;

#[arvik::handler]
impl Inspect {
    async fn call(&self, req: arvik::Request) -> String {
        req.uri().path().to_string()
    }
}

let app: Router<AppState> = Router::new()
    .routes(arvik::collect_routes![get_user])
    .route("/inspect", arvik::get(Inspect));

use arvik::{Router, TestClient, get};

let app = Router::new().route("/", get(|| async { "Hello" }));
let client = TestClient::new(app);

let res = client.get("/").header("x-test", "ok").send().await;
assert_eq!(res.status(), 200);
assert_eq!(res.text().await?, "Hello");

use arvik::ArvikConfig;

let config = ArvikConfig::builder()
    .file("arvik.toml")
    .env_prefix("ARVIK")
    .build()?;

let server_config = config.server_config();
let shutdown_config = config.shutdown_config();

use arvik::{
    Router, ShutdownConfig, default_shutdown_signal, get,
    serve_with_config_and_graceful_shutdown,
};
use std::time::Duration;

let app = Router::new().route("/", get(|| async { "Hello" }));
let shutdown = ShutdownConfig::default()
    .drain_timeout(Duration::from_secs(10))
    .on_connected(|info| println!("connected: {}", info.peer_addr))
    .on_disconnected(|info| println!("disconnected: {}", info.peer_addr));

serve_with_config_and_graceful_shutdown(
    app,
    "0.0.0.0:8080",
    arvik::ServerConfig::default(),
    shutdown,
    default_shutdown_signal(),
).await?;

use arvik::metrics::{PrometheusMetricsLayer, metrics_handler};
use arvik::trace::OtelLayer;
use arvik::logging::{ArvikLogger, StructuredLoggingLayer};

ArvikLogger::init()?;

let app = arvik::Router::new()
    .route("/metrics", arvik::get(metrics_handler))
    .route("/health", arvik::get(arvik::health::health_handler))
    .route("/health/live", arvik::get(arvik::health::liveness_handler))
    .route("/health/ready", arvik::get(arvik::health::readiness_handler))
    .layer(PrometheusMetricsLayer::new().service_name("api"))
    .layer(OtelLayer::new("api"))
    .layer(StructuredLoggingLayer::new());

use arvik::{Validate, ValidatedJson};
use serde::Deserialize;

#[derive(Deserialize, Validate)]
#[validate(crate = "arvik")]
struct CreateUser {
    #[validate(length(min = 2))]
    name: String,
    #[validate(email)]
    email: String,
}

async fn create_user(ValidatedJson(body): ValidatedJson<CreateUser>) -> String {
    body.email
}