Merge pull request #36 from tarone-saloni/Dark

Add Algorithm Learning Mode with Tutorials frontend

Author: CipherYuvraj

backend/main.py

@@ -1,11 +1,13 @@
 import os
 from pathlib import Path
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse
 from pydantic import BaseModel, ConfigDict
 from typing import List, Optional, Dict, Any
+from services.tutorial_service import TutorialService
+from models.tutorial_models import Tutorial
 import uvicorn
 
 app = FastAPI(
@@ -14,6 +16,31 @@
     version="1.0.0"
 )
 
+# Tutorial routes
+@app.get("/api/tutorials", response_model=List[Tutorial])
+async def get_tutorials(
+    difficulty: Optional[str] = Query(None, description="Filter tutorials by difficulty level"),
+    category: Optional[str] = Query(None, description="Filter tutorials by category")
+):
+    """
+    Get all tutorials with optional filtering by difficulty or category.
+    """
+    if difficulty:
+        return TutorialService.get_tutorials_by_difficulty(difficulty)
+    elif category:
+        return TutorialService.get_tutorials_by_category(category)
+    return TutorialService.get_all_tutorials()
+
+@app.get("/api/tutorials/{tutorial_id}", response_model=Tutorial)
+async def get_tutorial(tutorial_id: str):
+    """
+    Get a specific tutorial by ID.
+    """
+    tutorial = TutorialService.get_tutorial_by_id(tutorial_id)
+    if not tutorial:
+        raise HTTPException(status_code=404, detail="Tutorial not found")
+    return tutorial
+
 # Environment detection
 ENVIRONMENT = os.getenv("ENVIRONMENT", "development")
 IS_PRODUCTION = ENVIRONMENT == "production"

backend/models/tutorial_models.py

@@ -0,0 +1,31 @@
+from typing import List, Optional
+from pydantic import BaseModel
+
+class QuizOption(BaseModel):
+    text: str
+    isCorrect: bool
+
+class Quiz(BaseModel):
+    question: str
+    options: List[QuizOption]
+    explanation: Optional[str] = None
+
+class TutorialStep(BaseModel):
+    id: str
+    type: str  # 'explanation', 'quiz', 'interactive'
+    title: str
+    content: str
+    quiz: Optional[Quiz] = None
+    codeExample: Optional[str] = None
+    interactive: bool = False
+
+class Tutorial(BaseModel):
+    id: str
+    title: str
+    description: str
+    difficulty: str  # 'Beginner', 'Intermediate', 'Advanced'
+    estimatedTime: str
+    prerequisites: List[str]
+    steps: List[TutorialStep]
+    category: str  # 'sorting', 'graph', 'string', 'dp'
+    icon: str

backend/services/tutorial_service.py

@@ -0,0 +1,95 @@
+from typing import Dict, List, Optional
+from models.tutorial_models import Tutorial, TutorialStep, Quiz, QuizOption
+
+# Mock database of tutorials
+TUTORIALS_DB: Dict[str, Tutorial] = {
+    "sorting": Tutorial(
+        id="sorting",
+        title="Sorting Algorithms Mastery",
+        description="Learn about different sorting algorithms and their implementations",
+        difficulty="Beginner",
+        estimatedTime="30 minutes",
+        prerequisites=["basic-arrays"],
+        category="sorting",
+        icon="🔄",
+        steps=[
+            TutorialStep(
+                id="intro",
+                type="explanation",
+                title="Introduction to Sorting",
+                content="Sorting is a fundamental operation in computer science...",
+                interactive=True
+            ),
+            TutorialStep(
+                id="bubble-sort",
+                type="explanation",
+                title="Bubble Sort Algorithm",
+                content="Bubble Sort is the simplest sorting algorithm...",
+                codeExample="""def bubble_sort(arr):
+    n = len(arr)
+    for i in range(n):
+        for j in range(0, n-i-1):
+            if arr[j] > arr[j+1]:
+                arr[j], arr[j+1] = arr[j+1], arr[j]
+    return arr""",
+                interactive=True,
+                quiz=Quiz(
+                    question="What is the time complexity of Bubble Sort?",
+                    options=[
+                        QuizOption(text="O(n)", isCorrect=False),
+                        QuizOption(text="O(n²)", isCorrect=True),
+                        QuizOption(text="O(n log n)", isCorrect=False),
+                        QuizOption(text="O(1)", isCorrect=False)
+                    ],
+                    explanation="Bubble Sort uses nested loops, leading to O(n²) time complexity"
+                )
+            )
+        ]
+    ),
+    "graph": Tutorial(
+        id="graph",
+        title="Graph Algorithms",
+        description="Master graph traversal and pathfinding algorithms",
+        difficulty="Intermediate",
+        estimatedTime="45 minutes",
+        prerequisites=["basic-arrays", "sorting"],
+        category="graph",
+        icon="🕸️",
+        steps=[
+            TutorialStep(
+                id="intro",
+                type="explanation",
+                title="Introduction to Graphs",
+                content="Graphs are versatile data structures...",
+                interactive=True
+            )
+        ]
+    )
+}
+
+class TutorialService:
+    @staticmethod
+    def get_all_tutorials() -> List[Tutorial]:
+        """Get all available tutorials."""
+        return list(TUTORIALS_DB.values())
+
+    @staticmethod
+    def get_tutorial_by_id(tutorial_id: str) -> Optional[Tutorial]:
+        """Get a specific tutorial by ID."""
+        return TUTORIALS_DB.get(tutorial_id)
+
+    @staticmethod
+    def get_tutorials_by_difficulty(difficulty: str) -> List[Tutorial]:
+        """Get tutorials filtered by difficulty level."""
+        return [
+            tutorial for tutorial in TUTORIALS_DB.values()
+            if tutorial.difficulty.lower() == difficulty.lower()
+        ]
+
+    @staticmethod
+    def get_tutorials_by_category(category: str) -> List[Tutorial]:
+        """Get tutorials filtered by category."""
+        return [
+            tutorial for tutorial in TUTORIALS_DB.values()
+            if tutorial.category.lower() == category.lower()
+        ]