// Queries are verified at compile time — no runtime surprises
let user = sqlx::query_as!(
    User,
    "SELECT id, email, created_at FROM users WHERE id = $1",
    user_id
)
.fetch_one(&pool)
.await?;

// src/main.rs
use axum::{Router, routing::{get, post}};
use sqlx::PgPool;
use std::sync::Arc;
use tower_http::trace::TraceLayer;
use tracing_subscriber::EnvFilter;

mod handlers;
mod models;
mod errors;

#[derive(Clone)]
pub struct AppState {
    pub db: PgPool,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .init();

    let db_url = std::env::var("DATABASE_URL")?;
    let pool = PgPool::connect(&db_url).await?;

    // Run migrations on startup
    sqlx::migrate!("./migrations").run(&pool).await?;

    let state = Arc::new(AppState { db: pool });

    let app = Router::new()
        .route("/health", get(handlers::health))
        .route("/payments", post(handlers::create_payment))
        .route("/payments/:id", get(handlers::get_payment))
        .layer(TraceLayer::new_for_http())
        .with_state(state);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await?;
    tracing::info!("Listening on {}", listener.local_addr()?);
    axum::serve(listener, app).await?;

    Ok(())
}

// src/errors.rs
use axum::{response::{IntoResponse, Response}, http::StatusCode, Json};
use serde_json::json;

pub enum AppError {
    NotFound(String),
    DatabaseError(sqlx::Error),
    ValidationError(String),
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, message) = match self {
            AppError::NotFound(msg) => (StatusCode::NOT_FOUND, msg),
            AppError::DatabaseError(e) => {
                tracing::error!("Database error: {}", e);
                (StatusCode::INTERNAL_SERVER_ERROR, "Internal error".into())
            }
            AppError::ValidationError(msg) => (StatusCode::BAD_REQUEST, msg),
        };

        (status, Json(json!({ "error": message }))).into_response()
    }
}

impl From<sqlx::Error> for AppError {
    fn from(e: sqlx::Error) -> Self {
        match e {
            sqlx::Error::RowNotFound => AppError::NotFound("Resource not found".into()),
            other => AppError::DatabaseError(other),
        }
    }
}

// src/handlers.rs
use axum::{extract::{State, Path}, Json};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use uuid::Uuid;
use crate::{AppState, errors::AppError};

#[derive(Serialize)]
pub struct HealthResponse {
    status: &'static str,
    version: &'static str,
}

pub async fn health() -> Json<HealthResponse> {
    Json(HealthResponse { status: "ok", version: env!("CARGO_PKG_VERSION") })
}

#[derive(Deserialize)]
pub struct CreatePaymentRequest {
    amount_cents: i64,
    currency: String,
    description: Option<String>,
}

#[derive(Serialize)]
pub struct PaymentResponse {
    id: Uuid,
    amount_cents: i64,
    currency: String,
    status: String,
}

pub async fn create_payment(
    State(state): State<Arc<AppState>>,
    Json(req): Json<CreatePaymentRequest>,
) -> Result<Json<PaymentResponse>, AppError> {
    if req.amount_cents <= 0 {
        return Err(AppError::ValidationError("Amount must be positive".into()));
    }

    let payment = sqlx::query_as!(
        PaymentResponse,
        r#"
        INSERT INTO payments (id, amount_cents, currency, description, status)
        VALUES ($1, $2, $3, $4, 'pending')
        RETURNING id, amount_cents, currency, status
        "#,
        Uuid::new_v4(),
        req.amount_cents,
        req.currency,
        req.description
    )
    .fetch_one(&state.db)
    .await?;

    Ok(Json(payment))
}

// Handle SIGTERM/SIGINT gracefully
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel::<()>();

tokio::spawn(async move {
    tokio::signal::ctrl_c().await.expect("Failed to listen for ctrl_c");
    let _ = shutdown_tx.send(());
});

axum::serve(listener, app)
    .with_graceful_shutdown(async { shutdown_rx.await.ok(); })
    .await?;

let pool = PgPoolOptions::new()
    .max_connections(20)
    .min_connections(5)
    .acquire_timeout(Duration::from_secs(3))
    .idle_timeout(Duration::from_secs(600))
    .connect(&db_url)
    .await?;