// src/config.rs
use serde::Deserialize;

#[derive(Debug, Deserialize, Clone)]
pub struct Config {
    pub database_url: String,
    pub jwt_secret: String,
    pub jwt_expiration_hours: i64,
    pub server_port: u16,
    pub log_level: String,
}

impl Config {
    pub fn from_env() -> anyhow::Result<Self> {
        dotenvy::dotenv().ok();
        config::Config::builder()
            .add_source(config::Environment::default())
            .set_default("server_port", 8080)?
            .set_default("log_level", "info")?
            .set_default("jwt_expiration_hours", 24)?
            .build()?
            .try_deserialize()
            .map_err(Into::into)
    }
}

// src/state.rs
use sqlx::PgPool;
use std::sync::Arc;
use crate::config::Config;

#[derive(Clone)]
pub struct AppState {
    pub db: PgPool,
    pub config: Arc<Config>,
}

// 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("Not found: {0}")]
    NotFound(String),

    #[error("Unauthorized: {0}")]
    Unauthorized(String),

    #[error("Bad request: {0}")]
    BadRequest(String),

    #[error("Conflict: {0}")]
    Conflict(String),

    #[error("Internal error")]
    Internal(#[from] anyhow::Error),

    #[error("Database error")]
    Database(#[from] sqlx::Error),
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, message) = match &self {
            AppError::NotFound(msg) => (StatusCode::NOT_FOUND, msg.clone()),
            AppError::Unauthorized(msg) => (StatusCode::UNAUTHORIZED, msg.clone()),
            AppError::BadRequest(msg) => (StatusCode::BAD_REQUEST, msg.clone()),
            AppError::Conflict(msg) => (StatusCode::CONFLICT, msg.clone()),
            AppError::Internal(e) => {
                tracing::error!("Internal error: {:?}", e);
                (StatusCode::INTERNAL_SERVER_ERROR, "Internal server error".to_string())
            }
            AppError::Database(e) => {
                tracing::error!("Database error: {:?}", e);
                (StatusCode::INTERNAL_SERVER_ERROR, "Database error".to_string())
            }
        };

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

pub type AppResult<T> = Result<T, AppError>;

// src/models/task.rs
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use sqlx::FromRow;
use uuid::Uuid;
use validator::Validate;

#[derive(Debug, Serialize, Deserialize, FromRow)]
pub struct Task {
    pub id: Uuid,
    pub user_id: Uuid,
    pub title: String,
    pub description: Option<String>,
    pub status: TaskStatus,
    pub priority: Priority,
    pub due_at: Option<DateTime<Utc>>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Serialize, Deserialize, sqlx::Type, Clone, PartialEq)]
#[sqlx(type_name = "task_status", rename_all = "snake_case")]
pub enum TaskStatus {
    Todo,
    InProgress,
    Done,
    Cancelled,
}

#[derive(Debug, Serialize, Deserialize, sqlx::Type, Clone)]
#[sqlx(type_name = "priority", rename_all = "snake_case")]
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}

#[derive(Debug, Deserialize, Validate)]
pub struct CreateTaskRequest {
    #[validate(length(min = 1, max = 200))]
    pub title: String,
    #[validate(length(max = 2000))]
    pub description: Option<String>,
    pub priority: Option<Priority>,
    pub due_at: Option<DateTime<Utc>>,
}

#[derive(Debug, Deserialize, Validate)]
pub struct UpdateTaskRequest {
    #[validate(length(min = 1, max = 200))]
    pub title: Option<String>,
    pub description: Option<String>,
    pub status: Option<TaskStatus>,
    pub priority: Option<Priority>,
    pub due_at: Option<DateTime<Utc>>,
}

// src/handlers/tasks.rs
use axum::{
    extract::{Path, Query, State},
    http::StatusCode,
    Json,
};
use serde::Deserialize;
use uuid::Uuid;
use validator::Validate;

use crate::{
    auth::Claims,
    error::{AppError, AppResult},
    models::task::{CreateTaskRequest, Task, TaskStatus, UpdateTaskRequest},
    state::AppState,
};

#[derive(Debug, Deserialize)]
pub struct TaskListQuery {
    pub status: Option<TaskStatus>,
    pub limit: Option<i64>,
    pub offset: Option<i64>,
}

#[tracing::instrument(skip(state), fields(user_id = %claims.sub))]
pub async fn list_tasks(
    State(state): State<AppState>,
    claims: Claims,
    Query(query): Query<TaskListQuery>,
) -> AppResult<Json<Vec<Task>>> {
    let limit = query.limit.unwrap_or(50).min(100);
    let offset = query.offset.unwrap_or(0);
    let user_id = Uuid::parse_str(&claims.sub)
        .map_err(|_| AppError::Unauthorized("Invalid user ID".into()))?;

    let tasks = if let Some(status) = query.status {
        sqlx::query_as!(
            Task,
            r#"
            SELECT id, user_id, title, description,
                   status as "status: TaskStatus",
                   priority as "priority: Priority",
                   due_at, created_at, updated_at
            FROM tasks
            WHERE user_id = $1 AND status = $2
            ORDER BY created_at DESC
            LIMIT $3 OFFSET $4
            "#,
            user_id, status as _, limit, offset
        )
        .fetch_all(&state.db)
        .await?
    } else {
        sqlx::query_as!(
            Task,
            r#"
            SELECT id, user_id, title, description,
                   status as "status: TaskStatus",
                   priority as "priority: Priority",
                   due_at, created_at, updated_at
            FROM tasks
            WHERE user_id = $1
            ORDER BY created_at DESC
            LIMIT $2 OFFSET $3
            "#,
            user_id, limit, offset
        )
        .fetch_all(&state.db)
        .await?
    };

    Ok(Json(tasks))
}

#[tracing::instrument(skip(state))]
pub async fn create_task(
    State(state): State<AppState>,
    claims: Claims,
    Json(req): Json<CreateTaskRequest>,
) -> AppResult<(StatusCode, Json<Task>)> {
    req.validate().map_err(|e| AppError::BadRequest(e.to_string()))?;

    let user_id = Uuid::parse_str(&claims.sub)
        .map_err(|_| AppError::Unauthorized("Invalid user ID".into()))?;

    let task = sqlx::query_as!(
        Task,
        r#"
        INSERT INTO tasks (id, user_id, title, description, priority, due_at)
        VALUES ($1, $2, $3, $4, $5, $6)
        RETURNING id, user_id, title, description,
                  status as "status: TaskStatus",
                  priority as "priority: Priority",
                  due_at, created_at, updated_at
        "#,
        Uuid::new_v4(),
        user_id,
        req.title,
        req.description,
        req.priority.unwrap_or(Priority::Medium) as _,
        req.due_at,
    )
    .fetch_one(&state.db)
    .await?;

    tracing::info!(task_id = %task.id, "Task created");
    Ok((StatusCode::CREATED, Json(task)))
}

// src/main.rs
use axum::{
    Router,
    routing::{delete, get, patch, post},
};
use tower_http::{
    compression::CompressionLayer,
    cors::{Any, CorsLayer},
    trace::TraceLayer,
};
use std::sync::Arc;

mod auth;
mod config;
mod error;
mod handlers;
mod models;
mod state;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let config = config::Config::from_env()?;

    // Initialize tracing
    tracing_subscriber::fmt()
        .with_env_filter(&config.log_level)
        .json()
        .init();

    // Database pool
    let db = sqlx::PgPool::connect(&config.database_url).await?;
    sqlx::migrate!("./migrations").run(&db).await?;

    let state = state::AppState {
        db,
        config: Arc::new(config.clone()),
    };

    // Router
    let app = Router::new()
        .route("/health", get(handlers::health))
        .nest("/api/v1", api_routes())
        .with_state(state)
        .layer(
            tower::ServiceBuilder::new()
                .layer(TraceLayer::new_for_http())
                .layer(CompressionLayer::new())
                .layer(
                    CorsLayer::new()
                        .allow_origin(Any)
                        .allow_methods(Any)
                        .allow_headers(Any),
                ),
        );

    let addr = format!("0.0.0.0:{}", config.server_port);
    tracing::info!("Listening on {}", addr);
    let listener = tokio::net::TcpListener::bind(&addr).await?;
    axum::serve(listener, app).await?;

    Ok(())
}

fn api_routes() -> Router<state::AppState> {
    Router::new()
        .route("/auth/register", post(handlers::auth::register))
        .route("/auth/login", post(handlers::auth::login))
        .route("/tasks", get(handlers::tasks::list_tasks))
        .route("/tasks", post(handlers::tasks::create_task))
        .route("/tasks/:id", get(handlers::tasks::get_task))
        .route("/tasks/:id", patch(handlers::tasks::update_task))
        .route("/tasks/:id", delete(handlers::tasks::delete_task))
}

// tests/task_api_test.rs
use axum_test::TestServer;

#[tokio::test]
async fn test_create_task_success() {
    let app = create_test_app().await;
    let server = TestServer::new(app).unwrap();

    // First, get a JWT token
    let login_response = server
        .post("/api/v1/auth/login")
        .json(&json!({
            "email": "test@example.com",
            "password": "testpassword123"
        }))
        .await;
    login_response.assert_status_ok();
    let token = login_response.json::<serde_json::Value>()["token"]
        .as_str().unwrap().to_string();

    // Create a task
    let response = server
        .post("/api/v1/tasks")
        .add_header("Authorization", format!("Bearer {}", token))
        .json(&json!({
            "title": "Write integration tests",
            "priority": "high",
        }))
        .await;

    response.assert_status(StatusCode::CREATED);
    let task = response.json::<serde_json::Value>();
    assert_eq!(task["title"], "Write integration tests");
    assert_eq!(task["status"], "todo");
}