use axum::{
    extract::{Path, Query, State},
    http::StatusCode,
    middleware,
    response::Json,
    routing::{get, post},
    Router,
};
use serde::{Deserialize, Serialize};
use sqlx::PgPool;
use std::sync::Arc;
use tower_http::{cors::CorsLayer, trace::TraceLayer};
use uuid::Uuid;

// Application state — shared across all handlers
#[derive(Clone)]
struct AppState {
    db: PgPool,
    redis: redis::aio::ConnectionManager,
}

// Request/Response types — derive Serialize/Deserialize for free JSON
#[derive(Deserialize)]
struct CreateUserRequest {
    name: String,
    email: String,
}

#[derive(Serialize, sqlx::FromRow)]
struct User {
    id: Uuid,
    name: String,
    email: String,
    created_at: chrono::DateTime<chrono::Utc>,
}

#[derive(Deserialize)]
struct PaginationParams {
    #[serde(default = "default_page")]
    page: u32,
    #[serde(default = "default_per_page")]
    per_page: u32,
}

fn default_page() -> u32 { 1 }
fn default_per_page() -> u32 { 20 }

// Handlers
async fn list_users(
    State(state): State<Arc<AppState>>,
    Query(params): Query<PaginationParams>,
) -> Result<Json<Vec<User>>, AppError> {
    let offset = (params.page - 1) * params.per_page;
    
    let users = sqlx::query_as::<_, User>(
        "SELECT id, name, email, created_at FROM users ORDER BY created_at DESC LIMIT $1 OFFSET $2"
    )
    .bind(params.per_page as i64)
    .bind(offset as i64)
    .fetch_all(&state.db)
    .await?;

    Ok(Json(users))
}

async fn create_user(
    State(state): State<Arc<AppState>>,
    Json(payload): Json<CreateUserRequest>,
) -> Result<(StatusCode, Json<User>), AppError> {
    let user = sqlx::query_as::<_, User>(
        "INSERT INTO users (id, name, email) VALUES ($1, $2, $3) RETURNING *"
    )
    .bind(Uuid::new_v4())
    .bind(&payload.name)
    .bind(&payload.email)
    .fetch_one(&state.db)
    .await?;

    Ok((StatusCode::CREATED, Json(user)))
}

async fn get_user(
    State(state): State<Arc<AppState>>,
    Path(user_id): Path<Uuid>,
) -> Result<Json<User>, AppError> {
    let user = sqlx::query_as::<_, User>(
        "SELECT id, name, email, created_at FROM users WHERE id = $1"
    )
    .bind(user_id)
    .fetch_optional(&state.db)
    .await?
    .ok_or(AppError::NotFound)?;

    Ok(Json(user))
}

// Error handling — centralized, type-safe
#[derive(Debug)]
enum AppError {
    Database(sqlx::Error),
    NotFound,
    Unauthorized,
}

impl From<sqlx::Error> for AppError {
    fn from(e: sqlx::Error) -> Self {
        AppError::Database(e)
    }
}

impl axum::response::IntoResponse for AppError {
    fn into_response(self) -> axum::response::Response {
        let (status, message) = match self {
            AppError::Database(e) => {
                tracing::error!("Database error: {:?}", e);
                (StatusCode::INTERNAL_SERVER_ERROR, "Internal server error")
            }
            AppError::NotFound => (StatusCode::NOT_FOUND, "Resource not found"),
            AppError::Unauthorized => (StatusCode::UNAUTHORIZED, "Unauthorized"),
        };
        (status, Json(serde_json::json!({"error": message}))).into_response()
    }
}

#[tokio::main]
async fn main() {
    tracing_subscriber::init();
    
    let db = PgPool::connect(&std::env::var("DATABASE_URL").unwrap()).await.unwrap();
    let state = Arc::new(AppState {
        db,
        redis: todo!(), // redis setup
    });

    let app = Router::new()
        .route("/users", get(list_users).post(create_user))
        .route("/users/:id", get(get_user))
        .layer(TraceLayer::new_for_http())
        .layer(CorsLayer::permissive())
        .with_state(state);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

use axum::middleware::from_fn_with_state;
use tower::ServiceBuilder;
use tower_http::{
    compression::CompressionLayer,
    timeout::TimeoutLayer,
    limit::RequestBodyLimitLayer,
};

let app = Router::new()
    .route("/api/v1/users", get(list_users).post(create_user))
    // Auth middleware — runs before any route handler
    .route_layer(from_fn_with_state(state.clone(), auth_middleware))
    .layer(
        ServiceBuilder::new()
            .layer(TraceLayer::new_for_http())
            .layer(CompressionLayer::new())
            .layer(TimeoutLayer::new(Duration::from_secs(30)))
            .layer(RequestBodyLimitLayer::new(10 * 1024 * 1024)) // 10MB
            .layer(CorsLayer::new()
                .allow_origin(AllowOrigin::predicate(|origin, _| {
                    origin.as_bytes().ends_with(b".mycompany.com")
                }))
                .allow_methods([Method::GET, Method::POST, Method::PUT, Method::DELETE])
                .allow_headers(AllowHeaders::any())
            )
    )
    .with_state(state);

// This fails to compile if "user_emayl" doesn't match a real column
let user = sqlx::query_as!(
    User,
    r#"
    SELECT 
        id,
        name,
        email,
        created_at
    FROM users
    WHERE email = $1
      AND deleted_at IS NULL
    "#,
    email,
)
.fetch_optional(&pool)
.await?;

// Compile-time checked — no "column not found" at runtime

use leptos::prelude::*;

// This component runs on the server (SSR) AND the client (WASM)
// Same code, same types, no serialization boilerplate
#[component]
fn UserList() -> impl IntoView {
    // Server function — auto-generates API endpoint
    let users = Resource::new(|| (), |_| get_users());

    view! {
        <div class="user-list">
            <Suspense fallback=|| view! { <p>"Loading..."</p> }>
                {move || users.get().map(|data| match data {
                    Ok(users) => view! {
                        <ul>
                            {users.into_iter()
                                .map(|user| view! {
                                    <li key={user.id.to_string()}>
                                        <strong>{user.name}</strong>
                                        " — "
                                        {user.email}
                                    </li>
                                })
                                .collect::<Vec<_>>()}
                        </ul>
                    }.into_any(),
                    Err(e) => view! {
                        <p class="error">"Error: " {e.to_string()}</p>
                    }.into_any(),
                })}
            </Suspense>
        </div>
    }
}

// Server function — called from the component, executes on the server
#[server]
async fn get_users() -> Result<Vec<User>, ServerFnError> {
    let pool = use_context::<PgPool>().ok_or(ServerFnError::ServerError("No pool".into()))?;
    
    Ok(sqlx::query_as::<_, User>("SELECT * FROM users ORDER BY name")
        .fetch_all(&pool)
        .await?)
}