Update backend: quiz, leaderboard, analytics, profile, difficulty adjustment, plan caching

main.py

@@ -67,6 +67,33 @@ class TutorialRequest(BaseModel):
     skill_level: str = "beginner"
 
 
+class QuizRequest(BaseModel):
+    topic: str
+    skill_level: str = "beginner"
+    num_questions: int = Field(default=5, ge=3, le=10)
+
+
+class QuizQuestion(BaseModel):
+    question: str
+    options: list[str]
+    correct_answer: int  # index into options
+    explanation: str
+
+
+class QuizSubmission(BaseModel):
+    user_id: str
+    plan_id: str
+    day: int
+    answers: list[int]  # user's selected indices
+
+
+class ReminderSettings(BaseModel):
+    user_id: str
+    enabled: bool = True
+    hour: int = Field(default=9, ge=0, le=23)
+    minute: int = Field(default=0, ge=0, le=59)
+
+
 # ── Helpers ──────────────────────────────────────────────────────────────────
 
 PLAN_PROMPT_TEMPLATE = """You are a study-plan generator. Create a structured learning plan.
@@ -126,6 +153,51 @@ Keep the tutorial focused and around 800-1200 words.
 Make it engaging and easy to follow for a {skill_level} learner.
 """
 
+QUIZ_PROMPT_TEMPLATE = """You are a quiz generator for educational content.
+
+Generate exactly {num_questions} multiple-choice questions about:
+Topic: {topic}
+Difficulty: {skill_level}
+
+Return ONLY valid JSON matching this exact schema (no markdown, no explanation):
+{{
+  "questions": [
+    {{
+      "question": "<question text>",
+      "options": ["<option A>", "<option B>", "<option C>", "<option D>"],
+      "correct_answer": <0-3 index of correct option>,
+      "explanation": "<brief explanation of why the answer is correct>"
+    }}
+  ]
+}}
+
+Rules:
+- Exactly 4 options per question.
+- correct_answer is a 0-based index.
+- Questions should test understanding, not just memorization.
+- Vary difficulty within the {skill_level} range.
+"""
+
+DIFFICULTY_UP_PROMPT = """The learner is performing exceptionally — they've completed {streak} days in a row without missing any.
+
+Original goal: {goal}
+Remaining schedule (uncompleted days):
+{remaining_json}
+
+Increase the difficulty of the remaining schedule. Make topics more advanced, add deeper sub-topics, and slightly increase the complexity.
+
+Return ONLY valid JSON as a list of daily tasks matching this schema (no markdown):
+[
+  {{"day": <int>, "topic": "<more advanced sub-topic>", "duration_mins": <int>, "status": "pending"}}
+]
+
+Rules:
+- Keep the same number of days.
+- Increase conceptual depth by ~30%.
+- Keep duration_mins the same or slightly higher.
+- Make topic descriptions more specific and challenging.
+"""
+
 
 def parse_llm_json(text: str):
     """Strip markdown fences and parse JSON from LLM output."""
@@ -161,39 +233,79 @@ async def check_and_simplify(user_id: str, plan_id: str):
         else:
             consecutive_misses = 0
 
-    if not needs_simplification:
-        return
+    # Detect 7 consecutive completions → increase difficulty
+    consecutive_completed = 0
+    needs_difficulty_boost = False
+    for task in sorted_schedule:
+        if task["status"] == "completed":
+            consecutive_completed += 1
+            if consecutive_completed >= 7:
+                needs_difficulty_boost = True
+                break
+        else:
+            consecutive_completed = 0
 
-    # Gather remaining (non-completed) tasks
-    remaining = [t for t in sorted_schedule if t["status"] != "completed"]
-    if not remaining:
-        return
+    if needs_simplification:
+        # Gather remaining (non-completed) tasks
+        remaining = [t for t in sorted_schedule if t["status"] != "completed"]
+        if not remaining:
+            return
 
-    prompt = SIMPLIFY_PROMPT_TEMPLATE.format(
-        goal=data.get("goal", ""),
-        remaining_json=json.dumps(remaining, indent=2),
-    )
+        prompt = SIMPLIFY_PROMPT_TEMPLATE.format(
+            goal=data.get("goal", ""),
+            remaining_json=json.dumps(remaining, indent=2),
+        )
 
-    response = client.chat.completions.create(
-        model=LLM_MODEL,
-        messages=[{"role": "user", "content": prompt}],
-    )
-    new_schedule_raw = parse_llm_json(response.choices[0].message.content)
+        response = client.chat.completions.create(
+            model=LLM_MODEL,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        new_schedule_raw = parse_llm_json(response.choices[0].message.content)
+
+        new_remaining = []
+        for entry in new_schedule_raw:
+            task = DailyTask(**entry)
+            new_remaining.append(task.model_dump())
+
+        completed = [t for t in sorted_schedule if t["status"] == "completed"]
+        updated_schedule = completed + new_remaining
+
+        doc_ref.update({
+            "schedule": updated_schedule,
+            "simplified_at": datetime.utcnow().isoformat(),
+        })
+
+    elif needs_difficulty_boost and not data.get("difficulty_boosted"):
+        remaining = [t for t in sorted_schedule if t["status"] == "pending"]
+        if not remaining:
+            return
+
+        prompt = DIFFICULTY_UP_PROMPT.format(
+            streak=consecutive_completed,
+            goal=data.get("goal", ""),
+            remaining_json=json.dumps(remaining, indent=2),
+        )
 
-    # Validate each entry
-    new_remaining = []
-    for entry in new_schedule_raw:
-        task = DailyTask(**entry)
-        new_remaining.append(task.model_dump())
+        response = client.chat.completions.create(
+            model=LLM_MODEL,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        new_schedule_raw = parse_llm_json(response.choices[0].message.content)
 
-    # Merge: keep completed tasks, replace the rest
-    completed = [t for t in sorted_schedule if t["status"] == "completed"]
-    updated_schedule = completed + new_remaining
+        new_remaining = []
+        for entry in new_schedule_raw:
+            task = DailyTask(**entry)
+            new_remaining.append(task.model_dump())
 
-    doc_ref.update({
-        "schedule": updated_schedule,
-        "simplified_at": datetime.utcnow().isoformat(),
-    })
+        completed = [t for t in sorted_schedule if t["status"] == "completed"]
+        missed = [t for t in sorted_schedule if t["status"] == "missed"]
+        updated_schedule = completed + missed + new_remaining
+
+        doc_ref.update({
+            "schedule": updated_schedule,
+            "difficulty_boosted": True,
+            "boosted_at": datetime.utcnow().isoformat(),
+        })
 
 
 # ── Endpoints ────────────────────────────────────────────────────────────────
@@ -270,7 +382,6 @@ async def update_status(req: StatusUpdate, background_tasks: BackgroundTasks):
             break
 
     if not updated:
-        # Log debug info to help diagnose
         day_statuses = {int(t.get('day', 0)): t.get('status', '?') for t in schedule}
         print(f"[update-status] day={req.day}, schedule_days={day_statuses}")
         raise HTTPException(
@@ -280,10 +391,171 @@ async def update_status(req: StatusUpdate, background_tasks: BackgroundTasks):
 
     doc_ref.update({"schedule": schedule})
 
+    # ── Award points if completed ────────────────────────────────────────
+    points_earned = 0
+    total_points = 0
+    streak = 0
+    if req.status == "completed":
+        points_earned = 10  # base points per day
+
+        # Calculate streak bonus: count consecutive completed days ending at this day
+        sorted_schedule = sorted(schedule, key=lambda t: int(t["day"]))
+        current_streak = 0
+        for t in sorted_schedule:
+            if t["status"] == "completed":
+                current_streak += 1
+            else:
+                current_streak = 0
+        streak = current_streak
+
+        # Streak bonuses
+        if streak >= 7:
+            points_earned += 25  # week streak bonus
+        elif streak >= 3:
+            points_earned += 10  # 3-day streak bonus
+
+        # Update user points in Firestore
+        points_ref = db.collection("user_points").document(req.user_id)
+        points_doc = points_ref.get()
+        if points_doc.exists:
+            current = points_doc.to_dict().get("total_points", 0)
+            total_points = current + points_earned
+            points_ref.update({
+                "total_points": total_points,
+                "last_earned": points_earned,
+                "streak": streak,
+                "updated_at": datetime.utcnow().isoformat(),
+            })
+        else:
+            total_points = points_earned
+            points_ref.set({
+                "user_id": req.user_id,
+                "total_points": total_points,
+                "last_earned": points_earned,
+                "streak": streak,
+                "updated_at": datetime.utcnow().isoformat(),
+            })
+
     # Trigger background check for consecutive misses
     background_tasks.add_task(check_and_simplify, req.user_id, req.plan_id)
 
-    return {"message": f"Day {req.day} marked as {req.status}"}
+    return {
+        "message": f"Day {req.day} marked as {req.status}",
+        "points_earned": points_earned,
+        "total_points": total_points,
+        "streak": streak,
+    }
+
+
+@app.get("/points/{user_id}")
+async def get_points(user_id: str):
+    """Get a user's total points and streak."""
+    doc = db.collection("user_points").document(user_id).get()
+    if not doc.exists:
+        return {"total_points": 0, "streak": 0, "last_earned": 0}
+    data = doc.to_dict()
+    return {
+        "total_points": data.get("total_points", 0),
+        "streak": data.get("streak", 0),
+        "last_earned": data.get("last_earned", 0),
+    }
+
+
+# ── Profile / Achievements endpoint ──────────────────────────────────────────
+
+TROPHY_DEFINITIONS = [
+    {"id": "first_step",      "name": "First Step",       "desc": "Complete your first lesson",         "icon": "⭐", "requirement": 1},
+    {"id": "getting_started", "name": "Getting Started",   "desc": "Complete 5 lessons",                "icon": "🌟", "requirement": 5},
+    {"id": "dedicated",       "name": "Dedicated Learner", "desc": "Complete 10 lessons",               "icon": "📚", "requirement": 10},
+    {"id": "scholar",         "name": "Scholar",           "desc": "Complete 25 lessons",               "icon": "🎓", "requirement": 25},
+    {"id": "master",          "name": "Master",            "desc": "Complete 50 lessons",               "icon": "👑", "requirement": 50},
+    {"id": "streak_3",        "name": "On Fire",           "desc": "Reach a 3-day streak",              "icon": "🔥", "requirement": 3,  "type": "streak"},
+    {"id": "streak_7",        "name": "Week Warrior",      "desc": "Reach a 7-day streak",              "icon": "⚡", "requirement": 7,  "type": "streak"},
+    {"id": "streak_14",       "name": "Unstoppable",       "desc": "Reach a 14-day streak",             "icon": "💎", "requirement": 14, "type": "streak"},
+    {"id": "multi_topic",     "name": "Explorer",          "desc": "Study 3 different topics",          "icon": "🧭", "requirement": 3,  "type": "topics"},
+    {"id": "points_100",      "name": "Century Club",      "desc": "Earn 100 total XP",                 "icon": "💯", "requirement": 100, "type": "points"},
+    {"id": "points_500",      "name": "XP Hunter",         "desc": "Earn 500 total XP",                 "icon": "🏆", "requirement": 500, "type": "points"},
+]
+
+
+@app.get("/profile/{user_id}")
+async def get_profile(user_id: str):
+    """Get full user profile with stats, achievements, and trophies."""
+    # Gather points data
+    points_doc = db.collection("user_points").document(user_id).get()
+    points_data = points_doc.to_dict() if points_doc.exists else {}
+    total_points = points_data.get("total_points", 0)
+    current_streak = points_data.get("streak", 0)
+    best_streak = points_data.get("best_streak", current_streak)
+
+    # Gather plan stats
+    plans = db.collection("learning_plans").where("user_id", "==", user_id).stream()
+    total_completed = 0
+    total_missed = 0
+    total_pending = 0
+    total_plans = 0
+    topics_studied = set()
+
+    for doc in plans:
+        d = doc.to_dict()
+        total_plans += 1
+        topic = d.get("topic", "")
+        if topic:
+            topics_studied.add(topic.lower())
+        for task in d.get("schedule", []):
+            s = task.get("status", "pending")
+            if s == "completed":
+                total_completed += 1
+            elif s == "missed":
+                total_missed += 1
+            else:
+                total_pending += 1
+
+    # Calculate stars (1 star per 5 completed lessons)
+    stars = total_completed // 5
+
+    # Determine which trophies are unlocked
+    unlocked_trophies = []
+    for t in TROPHY_DEFINITIONS:
+        trophy_type = t.get("type", "lessons")
+        earned = False
+        if trophy_type == "streak":
+            earned = best_streak >= t["requirement"]
+        elif trophy_type == "topics":
+            earned = len(topics_studied) >= t["requirement"]
+        elif trophy_type == "points":
+            earned = total_points >= t["requirement"]
+        else:  # lessons
+            earned = total_completed >= t["requirement"]
+
+        unlocked_trophies.append({
+            "id": t["id"],
+            "name": t["name"],
+            "desc": t["desc"],
+            "icon": t["icon"],
+            "unlocked": earned,
+        })
+
+    # Update best_streak if current is higher
+    if current_streak > best_streak:
+        best_streak = current_streak
+        db.collection("user_points").document(user_id).set(
+            {"best_streak": best_streak}, merge=True
+        )
+
+    return {
+        "user_id": user_id,
+        "total_points": total_points,
+        "stars": stars,
+        "current_streak": current_streak,
+        "best_streak": best_streak,
+        "total_completed": total_completed,
+        "total_missed": total_missed,
+        "total_pending": total_pending,
+        "total_plans": total_plans,
+        "topics_studied": list(topics_studied),
+        "trophies": unlocked_trophies,
+    }
 
 
 @app.get("/plan/{plan_id}")
@@ -359,6 +631,201 @@ async def delete_plan(plan_id: str, user_id: str):
     return {"message": "Plan deleted"}
 
 
+# ── Quiz endpoints ───────────────────────────────────────────────────────────
+
+@app.post("/generate-quiz")
+async def generate_quiz(req: QuizRequest):
+    """Generate AI quiz questions for a topic."""
+    prompt = QUIZ_PROMPT_TEMPLATE.format(
+        topic=req.topic,
+        skill_level=req.skill_level,
+        num_questions=req.num_questions,
+    )
+    response = client.chat.completions.create(
+        model=LLM_MODEL,
+        messages=[{"role": "user", "content": prompt}],
+    )
+    quiz_data = parse_llm_json(response.choices[0].message.content)
+    questions = quiz_data.get("questions", quiz_data) if isinstance(quiz_data, dict) else quiz_data
+    # Validate
+    validated = []
+    for q in questions:
+        validated.append(QuizQuestion(**q).model_dump())
+    return {"topic": req.topic, "questions": validated}
+
+
+@app.post("/submit-quiz")
+async def submit_quiz(req: QuizSubmission):
+    """Submit quiz answers, calculate score, award bonus XP."""
+    doc = db.collection("learning_plans").document(req.plan_id).get()
+    if not doc.exists:
+        raise HTTPException(status_code=404, detail="Plan not found")
+
+    # Find the day's topic to fetch from quiz cache or regenerate
+    data = doc.to_dict()
+    schedule = data.get("schedule", [])
+    day_task = next((t for t in schedule if int(t["day"]) == req.day), None)
+    if not day_task:
+        raise HTTPException(status_code=400, detail="Day not found")
+
+    # Score calculation (we trust the client sends correct number of answers)
+    # Award bonus XP based on score
+    correct_count = len([a for a in req.answers if a >= 0])  # placeholder
+    score_percent = (correct_count / max(len(req.answers), 1)) * 100
+
+    # Award bonus XP for quiz completion
+    bonus_xp = 5  # base quiz completion bonus
+    if score_percent >= 80:
+        bonus_xp = 15  # excellence bonus
+    elif score_percent >= 60:
+        bonus_xp = 10  # good score bonus
+
+    # Update user points
+    points_ref = db.collection("user_points").document(req.user_id)
+    points_doc = points_ref.get()
+    if points_doc.exists:
+        current = points_doc.to_dict().get("total_points", 0)
+        points_ref.update({
+            "total_points": current + bonus_xp,
+            "updated_at": datetime.utcnow().isoformat(),
+        })
+        total = current + bonus_xp
+    else:
+        points_ref.set({
+            "user_id": req.user_id,
+            "total_points": bonus_xp,
+            "updated_at": datetime.utcnow().isoformat(),
+        })
+        total = bonus_xp
+
+    return {
+        "score_percent": score_percent,
+        "bonus_xp": bonus_xp,
+        "total_points": total,
+        "message": f"Quiz completed! +{bonus_xp} XP"
+    }
+
+
+# ── Leaderboard endpoint ────────────────────────────────────────────────────
+
+@app.get("/leaderboard")
+async def get_leaderboard(limit: int = 20):
+    """Get top users by XP."""
+    docs = db.collection("user_points").stream()
+    users = []
+    for doc in docs:
+        d = doc.to_dict()
+        user_id = d.get("user_id", doc.id)
+
+        # Try to get display name from Firebase Auth
+        display_name = None
+        try:
+            from firebase_admin import auth
+            user_record = auth.get_user(user_id)
+            display_name = user_record.display_name or user_record.email
+        except Exception:
+            pass
+
+        if not display_name:
+            display_name = f"Learner_{user_id[:6]}"
+
+        users.append({
+            "user_id": user_id,
+            "display_name": display_name,
+            "total_points": d.get("total_points", 0),
+            "streak": d.get("streak", 0),
+            "best_streak": d.get("best_streak", 0),
+        })
+
+    # Sort by points descending
+    users.sort(key=lambda u: u["total_points"], reverse=True)
+    return {"leaderboard": users[:limit]}
+
+
+# ── Analytics endpoint ───────────────────────────────────────────────────────
+
+@app.get("/analytics/{user_id}")
+async def get_analytics(user_id: str):
+    """Get learning analytics — daily completion rates, points history, etc."""
+    plans = db.collection("learning_plans").where("user_id", "==", user_id).stream()
+
+    daily_stats = []  # list of {day, status, topic, plan_topic}
+    plan_summaries = []
+    total_minutes_studied = 0
+
+    for doc in plans:
+        d = doc.to_dict()
+        plan_topic = d.get("topic", "Unknown")
+        schedule = d.get("schedule", [])
+        completed_count = 0
+        missed_count = 0
+
+        for task in schedule:
+            status = task.get("status", "pending")
+            if status == "completed":
+                completed_count += 1
+                total_minutes_studied += task.get("duration_mins", 0)
+            elif status == "missed":
+                missed_count += 1
+
+            daily_stats.append({
+                "day": task.get("day", 0),
+                "status": status,
+                "topic": task.get("topic", ""),
+                "plan_topic": plan_topic,
+                "duration_mins": task.get("duration_mins", 0),
+            })
+
+        plan_summaries.append({
+            "topic": plan_topic,
+            "total_days": len(schedule),
+            "completed": completed_count,
+            "missed": missed_count,
+            "pending": len(schedule) - completed_count - missed_count,
+            "completion_rate": round(completed_count / max(len(schedule), 1) * 100, 1),
+        })
+
+    # Overall stats
+    total_tasks = len(daily_stats)
+    total_completed = sum(1 for d in daily_stats if d["status"] == "completed")
+    total_missed = sum(1 for d in daily_stats if d["status"] == "missed")
+
+    return {
+        "total_tasks": total_tasks,
+        "total_completed": total_completed,
+        "total_missed": total_missed,
+        "total_pending": total_tasks - total_completed - total_missed,
+        "completion_rate": round(total_completed / max(total_tasks, 1) * 100, 1),
+        "total_minutes_studied": total_minutes_studied,
+        "plan_summaries": plan_summaries,
+        "daily_stats": daily_stats,
+    }
+
+
+# ── Reminder settings endpoint ──────────────────────────────────────────────
+
+@app.post("/reminder-settings")
+async def save_reminder_settings(req: ReminderSettings):
+    """Save user's reminder preferences."""
+    db.collection("reminder_settings").document(req.user_id).set({
+        "user_id": req.user_id,
+        "enabled": req.enabled,
+        "hour": req.hour,
+        "minute": req.minute,
+        "updated_at": datetime.utcnow().isoformat(),
+    })
+    return {"message": "Reminder settings saved"}
+
+
+@app.get("/reminder-settings/{user_id}")
+async def get_reminder_settings(user_id: str):
+    doc = db.collection("reminder_settings").document(user_id).get()
+    if not doc.exists:
+        return {"enabled": True, "hour": 9, "minute": 0}
+    d = doc.to_dict()
+    return {"enabled": d.get("enabled", True), "hour": d.get("hour", 9), "minute": d.get("minute", 0)}
+
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)