ayos / api / src / routes / progress.rs

use axum::extract::State;
use axum::Json;
use chrono::Utc;

use crate::auth::AuthUser;
use crate::config::AppState;
use crate::errors::AppError;
use crate::models::{
    LessonProgress, Progress, ProgressResponse, ProgressUpdateRequest, StatsResponse, UserStats,
};

// ---------------------------------------------------------------------------
// GET /api/progress
// ---------------------------------------------------------------------------

pub async fn get_progress(
    State(state): State<AppState>,
    AuthUser(user_id): AuthUser,
) -> Result<Json<ProgressResponse>, AppError> {
    let rows = sqlx::query_as::<_, Progress>(
        "SELECT user_id, topic_id, lesson_id, completed, best_score, completed_at \
         FROM progress WHERE user_id = ?",
    )
    .bind(&user_id)
    .fetch_all(&state.db)
    .await?;

    let stats = sqlx::query_as::<_, UserStats>(
        "SELECT user_id, xp, streak_days, last_active_date, hearts \
         FROM user_stats WHERE user_id = ?",
    )
    .bind(&user_id)
    .fetch_optional(&state.db)
    .await?
    .ok_or_else(|| AppError::NotFound("User stats not found".to_string()))?;

    let lessons: Vec<LessonProgress> = rows
        .into_iter()
        .map(|p| LessonProgress {
            topic_id: p.topic_id,
            lesson_id: p.lesson_id,
            completed: p.completed != 0,
            best_score: p.best_score,
            completed_at: p.completed_at,
        })
        .collect();

    Ok(Json(ProgressResponse {
        lessons,
        stats: StatsResponse {
            xp: stats.xp,
            streak_days: stats.streak_days,
            hearts: stats.hearts,
        },
    }))
}

// ---------------------------------------------------------------------------
// PUT /api/progress
// ---------------------------------------------------------------------------

pub async fn update_progress(
    State(state): State<AppState>,
    AuthUser(user_id): AuthUser,
    Json(body): Json<ProgressUpdateRequest>,
) -> Result<Json<StatsResponse>, AppError> {
    let today = Utc::now().format("%Y-%m-%d").to_string();
    let now_iso = Utc::now().format("%Y-%m-%dT%H:%M:%S").to_string();

    // Upsert progress row.
    // If the row already exists, only update best_score when the new score is higher.
    let existing = sqlx::query_as::<_, Progress>(
        "SELECT user_id, topic_id, lesson_id, completed, best_score, completed_at \
         FROM progress WHERE user_id = ? AND topic_id = ? AND lesson_id = ?",
    )
    .bind(&user_id)
    .bind(&body.topic_id)
    .bind(&body.lesson_id)
    .fetch_optional(&state.db)
    .await?;

    match existing {
        Some(prev) => {
            let new_best = if body.score > prev.best_score {
                body.score
            } else {
                prev.best_score
            };
            sqlx::query(
                "UPDATE progress SET best_score = ?, completed = 1, completed_at = ? \
                 WHERE user_id = ? AND topic_id = ? AND lesson_id = ?",
            )
            .bind(new_best)
            .bind(&now_iso)
            .bind(&user_id)
            .bind(&body.topic_id)
            .bind(&body.lesson_id)
            .execute(&state.db)
            .await?;
        }
        None => {
            sqlx::query(
                "INSERT INTO progress (user_id, topic_id, lesson_id, completed, best_score, completed_at) \
                 VALUES (?, ?, ?, 1, ?, ?)",
            )
            .bind(&user_id)
            .bind(&body.topic_id)
            .bind(&body.lesson_id)
            .bind(body.score)
            .bind(&now_iso)
            .execute(&state.db)
            .await?;
        }
    }

    // Fetch current stats for streak calculation.
    let stats = sqlx::query_as::<_, UserStats>(
        "SELECT user_id, xp, streak_days, last_active_date, hearts \
         FROM user_stats WHERE user_id = ?",
    )
    .bind(&user_id)
    .fetch_one(&state.db)
    .await?;

    // Streak logic.
    let yesterday = (Utc::now() - chrono::Duration::days(1))
        .format("%Y-%m-%d")
        .to_string();

    let new_streak = match stats.last_active_date.as_deref() {
        Some(d) if d == today => stats.streak_days, // already active today, no-op
        Some(d) if d == yesterday => stats.streak_days + 1,
        _ => 1, // first time or gap in activity
    };

    let new_xp = stats.xp + body.xp_earned;

    sqlx::query(
        "UPDATE user_stats SET xp = ?, streak_days = ?, last_active_date = ? WHERE user_id = ?",
    )
    .bind(new_xp)
    .bind(new_streak)
    .bind(&today)
    .bind(&user_id)
    .execute(&state.db)
    .await?;

    Ok(Json(StatsResponse {
        xp: new_xp,
        streak_days: new_streak,
        hearts: stats.hearts,
    }))
}