// src/domain.rs
use serde::{Deserialize, Serialize};
use uuid::Uuid;

#[derive(Debug, Serialize, Deserialize, sqlx::FromRow)]
pub struct User {
    pub id: Uuid,
    pub email: String,
    pub name: String,
    pub created_at: time::OffsetDateTime,
}

#[derive(Debug, Deserialize)]
pub struct CreateUserRequest {
    pub email: String,
    pub name: String,
}

#[derive(Debug, Deserialize)]
pub struct UpdateUserRequest {
    pub name: Option<String>,
}

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

#[derive(Error, Debug)]
pub enum AppError {
    #[error("User not found")]
    NotFound,
    #[error("Email already exists")]
    Conflict,
    #[error("Database error: {0}")]
    Database(#[from] sqlx::Error),
    #[error("Validation error: {0}")]
    Validation(String),
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, message) = match &self {
            AppError::NotFound => (StatusCode::NOT_FOUND, self.to_string()),
            AppError::Conflict => (StatusCode::CONFLICT, self.to_string()),
            AppError::Database(_) => (StatusCode::INTERNAL_SERVER_ERROR, "Internal server error".into()),
            AppError::Validation(msg) => (StatusCode::BAD_REQUEST, msg.clone()),
        };
        (status, Json(json!({ "error": message }))).into_response()
    }
}

// src/repository.rs
use crate::{domain::{CreateUserRequest, User}, error::AppError};
use sqlx::PgPool;
use uuid::Uuid;

pub struct UserRepository {
    pool: PgPool,
}

impl UserRepository {
    pub fn new(pool: PgPool) -> Self {
        Self { pool }
    }

    pub async fn find_all(&self) -> Result<Vec<User>, AppError> {
        let users = sqlx::query_as!(
            User,
            "SELECT id, email, name, created_at FROM users ORDER BY created_at DESC"
        )
        .fetch_all(&self.pool)
        .await?;
        Ok(users)
    }

    pub async fn find_by_id(&self, id: Uuid) -> Result<User, AppError> {
        sqlx::query_as!(
            User,
            "SELECT id, email, name, created_at FROM users WHERE id = $1",
            id
        )
        .fetch_optional(&self.pool)
        .await?
        .ok_or(AppError::NotFound)
    }

    pub async fn create(&self, req: CreateUserRequest) -> Result<User, AppError> {
        let user = sqlx::query_as!(
            User,
            "INSERT INTO users (id, email, name) VALUES ($1, $2, $3) RETURNING id, email, name, created_at",
            Uuid::new_v4(),
            req.email,
            req.name,
        )
        .fetch_one(&self.pool)
        .await
        .map_err(|e| match e {
            sqlx::Error::Database(db_err) if db_err.constraint() == Some("users_email_key") => {
                AppError::Conflict
            }
            other => AppError::Database(other),
        })?;
        Ok(user)
    }

    pub async fn delete(&self, id: Uuid) -> Result<(), AppError> {
        let result = sqlx::query!("DELETE FROM users WHERE id = $1", id)
            .execute(&self.pool)
            .await?;

        if result.rows_affected() == 0 {
            return Err(AppError::NotFound);
        }
        Ok(())
    }
}

// src/handlers.rs
use crate::{domain::{CreateUserRequest, User}, error::AppError, repository::UserRepository};
use axum::{
    extract::{Path, State},
    http::StatusCode,
    Json,
};
use std::sync::Arc;
use uuid::Uuid;

type AppState = Arc<UserRepository>;

pub async fn list_users(
    State(repo): State<AppState>,
) -> Result<Json<Vec<User>>, AppError> {
    let users = repo.find_all().await?;
    Ok(Json(users))
}

pub async fn get_user(
    State(repo): State<AppState>,
    Path(id): Path<Uuid>,
) -> Result<Json<User>, AppError> {
    let user = repo.find_by_id(id).await?;
    Ok(Json(user))
}

pub async fn create_user(
    State(repo): State<AppState>,
    Json(payload): Json<CreateUserRequest>,
) -> Result<(StatusCode, Json<User>), AppError> {
    if payload.email.is_empty() || !payload.email.contains('@') {
        return Err(AppError::Validation("Invalid email address".into()));
    }
    let user = repo.create(payload).await?;
    Ok((StatusCode::CREATED, Json(user)))
}

pub async fn delete_user(
    State(repo): State<AppState>,
    Path(id): Path<Uuid>,
) -> Result<StatusCode, AppError> {
    repo.delete(id).await?;
    Ok(StatusCode::NO_CONTENT)
}

// src/main.rs
mod domain;
mod error;
mod handlers;
mod repository;

use axum::{
    routing::{delete, get, post},
    Router,
};
use repository::UserRepository;
use sqlx::postgres::PgPoolOptions;
use std::{net::SocketAddr, sync::Arc};
use tower_http::{compression::CompressionLayer, cors::CorsLayer, trace::TraceLayer};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

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

    let database_url = std::env::var("DATABASE_URL")
        .unwrap_or_else(|_| "postgres://localhost/user_service".to_string());

    let pool = PgPoolOptions::new()
        .max_connections(20)
        .connect(&database_url)
        .await?;

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

    let repo = Arc::new(UserRepository::new(pool));

    let app = Router::new()
        .route("/users", get(handlers::list_users).post(handlers::create_user))
        .route("/users/:id", get(handlers::get_user).delete(handlers::delete_user))
        .route("/health", get(|| async { "OK" }))
        .with_state(repo)
        .layer(TraceLayer::new_for_http())
        .layer(CompressionLayer::new())
        .layer(CorsLayer::permissive());

    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
    tracing::info!("Listening on {}", addr);

    let listener = tokio::net::TcpListener::bind(addr).await?;
    axum::serve(listener, app).await?;

    Ok(())
}

use tracing::{info, instrument, warn};
use opentelemetry::global;
use tracing_opentelemetry::OpenTelemetryLayer;

#[instrument(skip(repo), fields(user_id = %id))]
pub async fn get_user_with_tracing(
    State(repo): State<AppState>,
    Path(id): Path<Uuid>,
) -> Result<Json<User>, AppError> {
    info!("Fetching user");
    let user = repo.find_by_id(id).await.map_err(|e| {
        warn!(error = %e, "User fetch failed");
        e
    })?;
    info!(email = %user.email, "User found");
    Ok(Json(user))
}