🚀 Auto-deploy backend from GitHub (a17792b)

main.py

@@ -79,6 +79,8 @@ from services.user_provisioning_service import (
 )
 from routes.rag_routes import router as rag_router
 from routes.admin_model_routes import router as admin_model_router
+from routes.admin_routes import router as admin_pdf_router
+from routes.curriculum_routes import router as curriculum_router
 from routes.diagnostic import router as diagnostic_router
 from routes.video_routes import router as video_router
 from routes.quiz_battle import router as quiz_battle_router
@@ -372,6 +374,8 @@ ROLE_POLICIES: Dict[str, Set[str]] = {
     "/api/automation/data-imported": ADMIN_ONLY,
     "/api/automation/content-updated": ADMIN_ONLY,
     "/api/admin/model-config": ADMIN_ONLY,
+    "/api/admin/upload-pdf": ADMIN_ONLY,
+    "/api/admin/reingest-pdf": ADMIN_ONLY,
     "/api/admin/model-config/profile": ADMIN_ONLY,
     "/api/admin/model-config/override": ADMIN_ONLY,
     "/api/admin/model-config/reset": ADMIN_ONLY,
@@ -1026,6 +1030,8 @@ if HAS_RATE_LIMITING and setup_rate_limiting:  # type: ignore[truthy-function]
 
 app.include_router(rag_router)
 app.include_router(admin_model_router)
+app.include_router(admin_pdf_router)
+app.include_router(curriculum_router)
 app.include_router(diagnostic_router)
 app.include_router(video_router)
 app.include_router(quiz_battle_router)

rag/firebase_storage_loader.py

@@ -121,7 +121,7 @@ def list_curriculum_blobs(prefix: str = "curriculum/") -> List[Dict[str, str]]:
 # are included in the RAG pipeline.
 
 PDF_METADATA: Dict[str, dict] = {
-    # General Mathematics — SDO Navotas teaching module (100 pages, ~125k chars)
+    # General Mathematics Q1 — SDO Navotas teaching module (100 pages, ~117k chars)
     "curriculum/gen_math_sdo/SDO_Navotas_Gen.Math_SHS_1stSem.FV.pdf": {
         "subject": "General Mathematics",
         "subjectId": "gen-math",
@@ -130,22 +130,46 @@ PDF_METADATA: Dict[str, dict] = {
         "quarter": 1,
         "storage_path": "curriculum/gen_math_sdo/SDO_Navotas_Gen.Math_SHS_1stSem.FV.pdf",
     },
-    # Business Mathematics — SDO Navotas teaching module (100 pages, ~145k chars)
-    "curriculum/business_math/SDO_Navotas_Bus.Math_SHS_1stSem.FV.pdf": {
-        "subject": "Business Mathematics",
-        "subjectId": "business-math",
+    # General Mathematics Q2 — Interest & Annuities modules (~27-35 pages each)
+    "curriculum/general_math/genmath_q2_mod1_simpleandcompoundinterests_v2.pdf": {
+        "subject": "General Mathematics",
+        "subjectId": "gen-math",
         "type": "sdo_module",
-        "content_domain": "business",
-        "quarter": 1,
-        "storage_path": "curriculum/business_math/SDO_Navotas_Bus.Math_SHS_1stSem.FV.pdf",
+        "content_domain": "general",
+        "quarter": 2,
+        "storage_path": "curriculum/general_math/genmath_q2_mod1_simpleandcompoundinterests_v2.pdf",
+    },
+    "curriculum/general_math/genmath_q2_mod2_interestmaturityfutureandpresentvaluesinsimpleandcompoundinterests_v2.pdf": {
+        "subject": "General Mathematics",
+        "subjectId": "gen-math",
+        "type": "sdo_module",
+        "content_domain": "general",
+        "quarter": 2,
+        "storage_path": "curriculum/general_math/genmath_q2_mod2_interestmaturityfutureandpresentvaluesinsimpleandcompoundinterests_v2.pdf",
+    },
+    "curriculum/general_math/genmath_q2_mod3_SolvingProblemsInvolvingSimpleandCompoundInterest_v2.pdf": {
+        "subject": "General Mathematics",
+        "subjectId": "gen-math",
+        "type": "sdo_module",
+        "content_domain": "general",
+        "quarter": 2,
+        "storage_path": "curriculum/general_math/genmath_q2_mod3_SolvingProblemsInvolvingSimpleandCompoundInterest_v2.pdf",
+    },
+    "curriculum/general_math/genmath_q2_mod4_simpleandgeneralannuities_v2.pdf": {
+        "subject": "General Mathematics",
+        "subjectId": "gen-math",
+        "type": "sdo_module",
+        "content_domain": "general",
+        "quarter": 2,
+        "storage_path": "curriculum/general_math/genmath_q2_mod4_simpleandgeneralannuities_v2.pdf",
     },
-    # Statistics and Probability — SDO Navotas teaching module (100 pages, ~156k chars)
-    "curriculum/stat_prob/SDO_Navotas_STAT_PROB_SHS_1stSem.FV.pdf": {
+    # Statistics and Probability — Full textbook (331 pages, ~607k chars)
+    "curriculum/stat_prob/Full.pdf": {
         "subject": "Statistics and Probability",
         "subjectId": "stats-prob",
         "type": "sdo_module",
         "content_domain": "statistics",
         "quarter": 1,
-        "storage_path": "curriculum/stat_prob/SDO_Navotas_STAT_PROB_SHS_1stSem.FV.pdf",
+        "storage_path": "curriculum/stat_prob/Full.pdf",
     },
 }

routes/admin_routes.py

@@ -0,0 +1,87 @@
+from typing import Optional
+from fastapi import APIRouter, Depends, HTTPException, Request, UploadFile, File, Form, BackgroundTasks
+from pydantic import BaseModel
+import logging
+
+from rag.firebase_storage_loader import _init_firebase_storage, PDF_METADATA
+from scripts.ingest_from_storage import ingest_from_firebase_storage
+
+logger = logging.getLogger("mathpulse.admin")
+
+router = APIRouter(prefix="/api/admin", tags=["admin"])
+
+def require_admin(request: Request):
+    user = getattr(request.state, "user", None)
+    if user is None:
+        raise HTTPException(status_code=401, detail="Authentication required")
+    if user.role != "admin":
+        raise HTTPException(status_code=403, detail="Admin access required")
+    return user
+
+class ReingestRequest(BaseModel):
+    subjectId: Optional[str] = None
+    storagePath: Optional[str] = None
+
+@router.post("/upload-pdf")
+async def upload_pdf(
+    subjectId: str = Form(...),
+    subjectName: str = Form(...),
+    semester: int = Form(...),
+    quarter: int = Form(...),
+    file: UploadFile = File(...),
+    _admin=Depends(require_admin)
+):
+    if not file.filename.endswith('.pdf'):
+        raise HTTPException(status_code=400, detail="Only PDF files are allowed.")
+        
+    file_content = await file.read()
+    if len(file_content) > 50 * 1024 * 1024:
+        raise HTTPException(status_code=400, detail="File size exceeds 50MB limit.")
+        
+    _, bucket = _init_firebase_storage()
+    if not bucket:
+        raise HTTPException(status_code=500, detail="Firebase storage is not initialized.")
+        
+    storage_path = f"curriculum/{subjectId}/{file.filename}"
+    
+    try:
+        blob = bucket.blob(storage_path)
+        blob.upload_from_string(file_content, content_type="application/pdf")
+    except Exception as e:
+        logger.error(f"Failed to upload PDF: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to upload to Firebase Storage: {e}")
+        
+    # Update metadata in memory before reingesting
+    PDF_METADATA[storage_path] = {
+        "subject": subjectName,
+        "subjectId": subjectId,
+        "type": "uploaded_module",
+        "semester": semester,
+        "quarter": quarter
+    }
+    
+    # Reingest
+    try:
+        ingest_from_firebase_storage(force_reindex=True)
+    except Exception as e:
+        logger.error(f"Failed to trigger reingestion: {e}")
+        
+    storage_url = f"gs://{bucket.name}/{storage_path}"
+    return {
+        "success": True,
+        "chunkCount": 0,
+        "subjectId": subjectId,
+        "storageUrl": storage_url
+    }
+
+@router.post("/reingest-pdf")
+async def reingest_pdf(
+    req: Optional[ReingestRequest] = None,
+    _admin=Depends(require_admin)
+):
+    try:
+        ingest_from_firebase_storage(force_reindex=True)
+        return {"success": True, "message": "Reingestion triggered successfully."}
+    except Exception as e:
+        logger.error(f"Failed to reingest: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to reingest: {e}")

routes/curriculum_routes.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from services.curriculum_service import (
+    get_subject,
+    get_subjects,
+    get_topic,
+    get_topics,
+)
+
+logger = logging.getLogger("mathpulse.curriculum")
+router = APIRouter(prefix="/api/curriculum", tags=["curriculum"])
+
+
+class SubjectResponse(BaseModel):
+    id: str
+    code: str
+    name: str
+    gradeLevel: str
+    semester: str
+    color: str
+    pdfAvailable: bool
+    topics: list
+
+
+class TopicResponse(BaseModel):
+    id: str
+    name: str
+    unit: str
+
+
+@router.get("/subjects", response_model=list[SubjectResponse])
+async def list_subjects(grade_level: Optional[str] = Query(None, description="Filter by grade level (e.g., 'Grade 11', 'Grade 12')")):
+    """List all curriculum subjects, optionally filtered by grade level."""
+    subjects = get_subjects(grade_level)
+    return subjects
+
+
+@router.get("/subjects/{subject_id}", response_model=SubjectResponse)
+async def get_subject_by_id(subject_id: str):
+    """Get a specific subject by ID."""
+    subject = get_subject(subject_id)
+    if not subject:
+        raise HTTPException(status_code=404, detail=f"Subject not found: {subject_id}")
+    return subject
+
+
+@router.get("/subjects/{subject_id}/topics", response_model=list[TopicResponse])
+async def list_subject_topics(subject_id: str):
+    """List all topics for a subject."""
+    topics = get_topics(subject_id)
+    return topics
+
+
+@router.get("/subjects/{subject_id}/topics/{topic_id}", response_model=TopicResponse)
+async def get_topic_by_id(subject_id: str, topic_id: str):
+    """Get a specific topic."""
+    topic = get_topic(subject_id, topic_id)
+    if not topic:
+        raise HTTPException(status_code=404, detail=f"Topic not found: {subject_id}/{topic_id}")
+    return topic

scripts/ingest_from_storage.py

@@ -70,13 +70,14 @@ def _classify_lesson_section(content: str) -> str:
 
 def chunk_text_preserve_pages(text: str, page_starts: List[int], chunk_size: int = 500, overlap: int = 80) -> List[Dict[str, Any]]:
     """Split text into overlapping chunks, preserving page traceability."""
-    words = text.split()
+    # Filter out None/empty entries that can result from malformed PDF text extraction
+    words = [w for w in text.split() if w is not None and str(w).strip()]
     chunks = []
     i = 0
     chunk_idx = 0
     while i < len(words):
         chunk_words = words[i : i + chunk_size]
-        chunk_text = " ".join(chunk_words)
+        chunk_text = " ".join(str(w) for w in chunk_words)
         estimated_page = max(1, (i // chunk_size) + 1)
         content_domain, chunk_type = _classify_chunk(chunk_text)
 
@@ -218,12 +219,20 @@ def ingest_from_firebase_storage(force_reindex: bool = False):
             logger.info("  Removed %d existing chunks", len(existing_ids))
 
         for chunk in chunks:
+            chunk_text = chunk.get("text", "")
+            if not isinstance(chunk_text, str) or not chunk_text.strip():
+                logger.warning("  Skipping empty/invalid chunk %s (type=%s, len=%d)", chunk.get("chunk_index"), type(chunk_text), len(chunk_text))
+                continue
             chunk_id = f"{doc_id}_chunk_{chunk['chunk_index']}"
-            embedding = embedder.encode(chunk["text"], normalize_embeddings=True).tolist()
+            try:
+                embedding = embedder.encode(chunk_text, normalize_embeddings=True).tolist()
+            except Exception as enc_err:
+                logger.warning("  Skipping unencodable chunk %s: %s", chunk.get("chunk_index"), enc_err)
+                continue
 
             collection.add(
                 embeddings=[embedding],
-                documents=[chunk["text"]],
+                documents=[chunk_text],
                 metadatas=[{
                     "document_id": doc_id,
                     "module_id": metadata.get("subjectId", ""),

scripts/migrate_grade12_to_grade11.py

@@ -0,0 +1,107 @@
+"""
+Migrate Grade 12 users to Grade 11.
+
+Run this to convert all existing Grade 12 users to Grade 11:
+    python backend/scripts/migrate_grade12_to_grade11.py
+
+This handles:
+- Firestore user profiles
+- Progress records
+- Any references to Grade 12
+"""
+
+import logging
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+logger = logging.getLogger(__name__)
+
+
+def migrate_grade_12_to_grade_11():
+    """Migrate all Grade 12 users to Grade 11."""
+    try:
+        import firebase_admin
+        from firebase_admin import firestore
+
+        svc_account = os.getenv("FIREBASE_SERVICE_ACCOUNT_JSON")
+        if svc_account:
+            import json
+            from firebase_admin import credentials
+            creds = credentials.Certificate(json.loads(svc_account))
+            firebase_admin.initialize_app(creds)
+        else:
+            firebase_admin.initialize_app()
+
+        db = firestore.client()
+        print("Firebase initialized")
+
+    except Exception as e:
+        print(f"Failed to initialize Firebase: {e}")
+        return
+
+    # Count migrations
+    users_migrated = 0
+    progress_migrated = 0
+
+    # Migrate users collection
+    print("\n--- Migrating users ---")
+    users_ref = db.collection("users")
+    
+    # Batch update for users
+    batch = db.batch()
+    user_count = 0
+
+    for doc in users_ref.stream():
+        data = doc.to_dict()
+        if data.get("grade") == "Grade 12":
+            batch.update(doc.reference, {"grade": "Grade 11"})
+            user_count += 1
+            print(f"  Migrating user: {doc.id} ({data.get('name', 'Unknown')})")
+            
+            if user_count >= 500:
+                batch.commit()
+                users_migrated += user_count
+                user_count = 0
+                batch = db.batch()
+
+    if user_count > 0:
+        batch.commit()
+        users_migrated += user_count
+
+    print(f"  => Migrated {users_migrated} users to Grade 11")
+
+    # Migrate progress collection
+    print("\n--- Migrating progress ---")
+    progress_ref = db.collection("progress")
+    batch = db.batch()
+    progress_count = 0
+
+    for doc in progress_ref.stream():
+        data = doc.to_dict()
+        if data.get("gradeLevel") == "Grade 12":
+            batch.update(doc.reference, {"gradeLevel": "Grade 11"})
+            progress_count += 1
+            
+            if progress_count >= 500:
+                batch.commit()
+                progress_migrated += progress_count
+                progress_count = 0
+                batch = db.batch()
+
+    if progress_count > 0:
+        batch.commit()
+        progress_migrated += progress_count
+
+    print(f"  => Migrated {progress_migrated} progress records to Grade 11")
+
+    print(f"\n=== Migration complete ===")
+    print(f"Users migrated: {users_migrated}")
+    print(f"Progress migrated: {progress_migrated}")
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    migrate_grade_12_to_grade_11()

scripts/seed_curriculum.py

@@ -0,0 +1,64 @@
+"""
+Seed Firestore curriculum collection from static data.
+
+Run this ONCE to migrate static curriculum to Firestore:
+    python backend/scripts/seed_curriculum.py
+
+After seeding, the curriculum API will read from Firestore.
+"""
+
+import logging
+import json
+import os
+import sys
+from pathlib import Path
+
+# Add backend to path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from services.curriculum_service import _STATIC_SUBJECTS
+
+logger = logging.getLogger(__name__)
+
+
+def seed_curriculum():
+    """Seed curriculum subjects to Firestore."""
+    try:
+        import firebase_admin
+        from firebase_admin import firestore, credentials
+
+        # Initialize Firebase
+        svc_account = os.getenv("FIREBASE_SERVICE_ACCOUNT_JSON")
+        if svc_account:
+            sa_creds = credentials.Certificate(json.loads(svc_account))
+            firebase_admin.initialize_app(sa_creds)
+        else:
+            firebase_admin.initialize_app()
+
+        db = firestore.client()
+        print("Firebase initialized")
+
+    except Exception as e:
+        print(f"Failed to initialize Firebase: {e}")
+        return
+
+    # Seed new subjects
+    subjects_ref = db.collection("subjects")
+    count = 0
+
+    for subject in _STATIC_SUBJECTS:
+        doc_ref = subjects_ref.document(subject["id"])
+        doc_ref.set(subject)
+        count += 1
+        print(f"  Seeded: {subject['id']} - {subject['name']} ({len(subject.get('topics', []))} topics)")
+
+    print(f"\nSeeded {count} subjects to Firestore")
+    print("\nCurriculum is now available at:")
+    print("  GET /api/curriculum/subjects")
+    print("  GET /api/curriculum/subjects/{id}")
+    print("  GET /api/curriculum/subjects/{id}/topics")
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    seed_curriculum()

scripts/upload_lesson_modules.py

@@ -0,0 +1,142 @@
+"""
+Merge DepEd lesson module PDFs and upload to Firebase Storage.
+Run: python backend/scripts/upload_lesson_modules.py
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from pypdf import PdfWriter, PdfReader
+
+LOCAL_MODULES_DIR = Path(__file__).resolve().parents[1].parent / "datasets" / "lesson_modules"
+FIREBASE_STORAGE_BUCKET = "mathpulse-ai-2026.firebasestorage.app"
+
+# Upload plan
+UPLOAD_JOBS = [
+    {
+        "id": "basic-calc-q3",
+        "display_name": "Basic Calculus Q3",
+        "subject": "Basic Calculus",
+        "subjectId": "basic-calc",
+        "quarter": 3,
+        "storage_path": "curriculum/basic_calc/SDO_Navotas_BasicCalc_SHS_Q3.FV.pdf",
+        "local_dir": LOCAL_MODULES_DIR / "basic_calculus_q3",
+        "filename": "Basic Calculus-Q3-Module-{n}.pdf",
+        "modules": list(range(1, 9)),  # Modules 1-8
+    },
+    {
+        "id": "gen-math-q2",
+        "display_name": "General Mathematics Q2",
+        "subject": "General Mathematics",
+        "subjectId": "gen-math",
+        "quarter": 2,
+        "storage_path": "curriculum/gen_math_q2/SDO_Navotas_GenMath_SHS_Q2.FV.pdf",
+        "local_dir": LOCAL_MODULES_DIR / "genmath_q2",
+        "filename": "genmath_q2_mod{n}_*.pdf",
+        "modules": [2, 3],  # Modules 2 and 3 only
+    },
+]
+
+
+def merge_pdfs(job: dict) -> Path | None:
+    """Merge multiple PDFs into a single output file. Returns output path."""
+    output_dir = LOCAL_MODULES_DIR / "merged"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    output_path = output_dir / f"{job['id']}_merged.pdf"
+
+    writer = PdfWriter()
+
+    for mod_num in job["modules"]:
+        if job["id"] == "basic-calc-q3":
+            fname = job["filename"].format(n=mod_num)
+        else:
+            # GenMath modules have specific naming
+            fname = None
+            pattern = job["filename"].format(n=mod_num)
+            for f in job["local_dir"].glob(pattern):
+                fname = f.name
+                break
+            if fname is None:
+                print(f"  [WARN] Could not find file for module {mod_num}")
+                continue
+
+        src_path = job["local_dir"] / fname
+        if not src_path.exists():
+            print(f"  [WARN] File not found: {src_path}")
+            continue
+
+        reader = PdfReader(str(src_path))
+        print(f"  + {src_path.name} ({len(reader.pages)} pages)")
+        for page in reader.pages:
+            writer.add_page(page)
+
+    print(f"  Writing {output_path.name} ({len(writer.pages)} total pages)")
+    with open(output_path, "wb") as f:
+        writer.write(f)
+
+    return output_path
+
+
+def upload_to_firebase(local_path: Path, storage_path: str) -> bool:
+    """Upload a PDF file to Firebase Storage."""
+    try:
+        import firebase_admin
+        from firebase_admin import credentials, storage
+    except ImportError:
+        print("  ERROR: firebase-admin not installed")
+        return False
+
+    sa_file = Path(__file__).resolve().parents[1].parent / ".secrets" / "firebase-service-account.json"
+    if not sa_file.exists():
+        print(f"  ERROR: Service account not found at {sa_file}")
+        return False
+
+    if not firebase_admin._apps:
+        cred = credentials.Certificate(str(sa_file))
+        firebase_admin.initialize_app(cred, {"storageBucket": FIREBASE_STORAGE_BUCKET})
+
+    bucket = storage.bucket()
+    blob = bucket.blob(storage_path)
+
+    print(f"  Uploading to gs://{bucket.name}/{storage_path}")
+    blob.upload_from_filename(str(local_path), content_type="application/pdf")
+    print(f"  Upload complete!")
+    return True
+
+
+def main():
+    print("=" * 60)
+    print("MathPulse AI — Lesson Module PDF Uploader")
+    print("=" * 60)
+
+    for job in UPLOAD_JOBS:
+        print(f"\n[{job['display_name']}]")
+        print("-" * 40)
+
+        # Step 1: Merge PDFs
+        output_path = merge_pdfs(job)
+        if not output_path or not output_path.exists():
+            print(f"  [FAIL] Merge failed for {job['id']}")
+            continue
+
+        # Step 2: Upload to Firebase
+        success = upload_to_firebase(output_path, job["storage_path"])
+        if not success:
+            print(f"  [FAIL] Upload failed for {job['id']}")
+            continue
+
+        print(f"\n  SUCCESS: {job['display_name']}")
+        print(f"  Storage path: gs://{FIREBASE_STORAGE_BUCKET}/{job['storage_path']}")
+        print(f"  Pages: {len(PdfReader(str(output_path)).pages)}")
+
+    print("\n" + "=" * 60)
+    print("Done!")
+
+
+if __name__ == "__main__":
+    main()

services/curriculum_service.py

@@ -0,0 +1,232 @@
+"""
+Curriculum Service - Firestore-backed curriculum data.
+
+Fetches subjects, topics, and modules from Firestore.
+Falls back to static data if Firestore is unavailable.
+"""
+
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+# Static curriculum data as fallback
+_STATIC_SUBJECTS = [
+    {
+        "id": "gen-math",
+        "code": "GEN MATH",
+        "name": "General Mathematics",
+        "gradeLevel": "Grade 11",
+        "semester": "1st Semester",
+        "color": "from-blue-500 to-cyan-500",
+        "pdfAvailable": True,
+        "topics": [
+            {"id": "gen-math-001", "name": "Patterns and Real-Life Relationships", "unit": "Patterns, Relations, and Functions"},
+            {"id": "gen-math-002", "name": "Functions as Mathematical Models", "unit": "Patterns, Relations, and Functions"},
+            {"id": "gen-math-003", "name": "Function Notation and Evaluation", "unit": "Patterns, Relations, and Functions"},
+            {"id": "gen-math-004", "name": "Domain and Range of Functions", "unit": "Patterns, Relations, and Functions"},
+            {"id": "gen-math-005", "name": "Operations on Functions", "unit": "Patterns, Relations, and Functions"},
+            {"id": "gen-math-006", "name": "Composite Functions", "unit": "Patterns, Relations, and Functions"},
+            {"id": "gen-math-007", "name": "Inverse Functions", "unit": "Patterns, Relations, and Functions"},
+            {"id": "gen-math-008", "name": "Graphs of Rational Functions", "unit": "Patterns, Relations, and Functions"},
+            {"id": "gen-math-009", "name": "Graphs of Exponential Functions", "unit": "Patterns, Relations, and Functions"},
+            {"id": "gen-math-010", "name": "Graphs of Logarithmic Functions", "unit": "Patterns, Relations, and Functions"},
+            {"id": "gen-math-011", "name": "Simple and Compound Interest", "unit": "Financial Mathematics"},
+            {"id": "gen-math-012", "name": "Simple and General Annuities", "unit": "Financial Mathematics"},
+            {"id": "gen-math-013", "name": "Present and Future Value", "unit": "Financial Mathematics"},
+            {"id": "gen-math-014", "name": "Loans, Amortization, and Sinking Funds", "unit": "Financial Mathematics"},
+            {"id": "gen-math-015", "name": "Stocks, Bonds, and Market Indices", "unit": "Financial Mathematics"},
+            {"id": "gen-math-016", "name": "Business Decision-Making with Mathematical Models", "unit": "Financial Mathematics"},
+            {"id": "gen-math-017", "name": "Propositions and Logical Connectives", "unit": "Logic and Mathematical Reasoning"},
+            {"id": "gen-math-018", "name": "Truth Values and Truth Tables", "unit": "Logic and Mathematical Reasoning"},
+            {"id": "gen-math-019", "name": "Logical Equivalence and Implication", "unit": "Logic and Mathematical Reasoning"},
+            {"id": "gen-math-020", "name": "Quantifiers and Negation", "unit": "Logic and Mathematical Reasoning"},
+            {"id": "gen-math-021", "name": "Validity of Arguments", "unit": "Logic and Mathematical Reasoning"},
+        ]
+    },
+    {
+        "id": "stats-prob",
+        "code": "STAT&PROB",
+        "name": "Statistics and Probability",
+        "gradeLevel": "Grade 11",
+        "semester": "2nd Semester",
+        "color": "from-sky-500 to-cyan-500",
+        "pdfAvailable": True,
+        "topics": [
+            {"id": "stat-001", "name": "Random Variables", "unit": "Random Variables"},
+            {"id": "stat-002", "name": "Discrete Probability Distributions", "unit": "Random Variables"},
+            {"id": "stat-003", "name": "Mean and Variance of Discrete RV", "unit": "Random Variables"},
+            {"id": "stat-004", "name": "Normal Distribution", "unit": "Normal Distribution"},
+            {"id": "stat-005", "name": "Standard Normal Distribution and Z-scores", "unit": "Normal Distribution"},
+            {"id": "stat-006", "name": "Areas Under the Normal Curve", "unit": "Normal Distribution"},
+            {"id": "stat-007", "name": "Sampling Distributions", "unit": "Sampling and Estimation"},
+            {"id": "stat-008", "name": "Central Limit Theorem", "unit": "Sampling and Estimation"},
+            {"id": "stat-009", "name": "Point Estimation", "unit": "Sampling and Estimation"},
+            {"id": "stat-010", "name": "Confidence Intervals", "unit": "Sampling and Estimation"},
+            {"id": "stat-011", "name": "Hypothesis Testing Concepts", "unit": "Hypothesis Testing"},
+            {"id": "stat-012", "name": "T-test", "unit": "Hypothesis Testing"},
+            {"id": "stat-013", "name": "Z-test", "unit": "Hypothesis Testing"},
+            {"id": "stat-014", "name": "Correlation and Regression", "unit": "Correlation and Regression"},
+        ]
+    },
+    {
+        "id": "pre-calc",
+        "code": "PRE-CALC",
+        "name": "Pre-Calculus",
+        "gradeLevel": "Grade 12",
+        "semester": "1st Semester",
+        "color": "from-orange-500 to-red-500",
+        "pdfAvailable": False,
+        "topics": [
+            {"id": "pre-calc-001", "name": "Conic Sections - Parabola", "unit": "Analytic Geometry"},
+            {"id": "pre-calc-002", "name": "Conic Sections - Ellipse", "unit": "Analytic Geometry"},
+            {"id": "pre-calc-003", "name": "Conic Sections - Hyperbola", "unit": "Analytic Geometry"},
+            {"id": "pre-calc-004", "name": "Conic Sections - Circle", "unit": "Analytic Geometry"},
+            {"id": "pre-calc-005", "name": "Systems of Nonlinear Equations", "unit": "Analytic Geometry"},
+            {"id": "pre-calc-006", "name": "Sequences and Series", "unit": "Series and Induction"},
+            {"id": "pre-calc-007", "name": "Arithmetic Sequences", "unit": "Series and Induction"},
+            {"id": "pre-calc-008", "name": "Geometric Sequences", "unit": "Series and Induction"},
+            {"id": "pre-calc-009", "name": "Mathematical Induction", "unit": "Series and Induction"},
+            {"id": "pre-calc-010", "name": "Binomial Theorem", "unit": "Series and Induction"},
+            {"id": "pre-calc-011", "name": "Angles and Unit Circle", "unit": "Trigonometry"},
+            {"id": "pre-calc-012", "name": "Trigonometric Functions", "unit": "Trigonometry"},
+            {"id": "pre-calc-013", "name": "Trigonometric Identities", "unit": "Trigonometry"},
+            {"id": "pre-calc-014", "name": "Sum and Difference Formulas", "unit": "Trigonometry"},
+            {"id": "pre-calc-015", "name": "Inverse Trigonometric Functions", "unit": "Trigonometry"},
+            {"id": "pre-calc-016", "name": "Polar Coordinates", "unit": "Trigonometry"},
+        ]
+    },
+    {
+        "id": "basic-calc",
+        "code": "BASIC CALC",
+        "name": "Basic Calculus",
+        "gradeLevel": "Grade 12",
+        "semester": "2nd Semester",
+        "color": "from-green-500 to-teal-500",
+        "pdfAvailable": True,
+        "topics": [
+            {"id": "calc-001", "name": "Limits of Functions", "unit": "Limits"},
+            {"id": "calc-002", "name": "Limit Theorems", "unit": "Limits"},
+            {"id": "calc-003", "name": "One-Sided Limits", "unit": "Limits"},
+            {"id": "calc-004", "name": "Infinite Limits and Limits at Infinity", "unit": "Limits"},
+            {"id": "calc-005", "name": "Continuity of Functions", "unit": "Limits"},
+            {"id": "calc-006", "name": "Definition of the Derivative", "unit": "Derivatives"},
+            {"id": "calc-007", "name": "Differentiation Rules", "unit": "Derivatives"},
+            {"id": "calc-008", "name": "Chain Rule", "unit": "Derivatives"},
+            {"id": "calc-009", "name": "Implicit Differentiation", "unit": "Derivatives"},
+            {"id": "calc-010", "name": "Higher-Order Derivatives", "unit": "Derivatives"},
+            {"id": "calc-011", "name": "Related Rates", "unit": "Derivatives"},
+            {"id": "calc-012", "name": "Extrema and the First Derivative Test", "unit": "Derivatives"},
+            {"id": "calc-013", "name": "Concavity and the Second Derivative Test", "unit": "Derivatives"},
+            {"id": "calc-014", "name": "Optimization Problems", "unit": "Derivatives"},
+            {"id": "calc-015", "name": "Antiderivatives and Indefinite Integrals", "unit": "Integration"},
+            {"id": "calc-016", "name": "Definite Integrals and the FTC", "unit": "Integration"},
+            {"id": "calc-017", "name": "Integration by Substitution", "unit": "Integration"},
+            {"id": "calc-018", "name": "Area Under a Curve", "unit": "Integration"},
+        ]
+    },
+]
+
+_firestore_db = None
+
+
+def _get_firestore_db():
+    """Initialize Firestore client."""
+    global _firestore_db
+    if _firestore_db is not None:
+        return _firestore_db
+
+    try:
+        import firebase_admin
+        from firebase_admin import firestore
+        if not firebase_admin._apps:
+            # Try service account from env or default credentials
+            import json
+            svc_account = os.getenv("FIREBASE_SERVICE_ACCOUNT_JSON")
+            if svc_account:
+                sa_creds = json.loads(svc_account)
+                firebase_admin.initialize_app(firebase_admin.Certificate(sa_creds))
+            else:
+                firebase_admin.initialize_app()
+        _firestore_db = firestore.client()
+        return _firestore_db
+    except Exception as e:
+        logger.warning(f"Could not initialize Firestore: {e}")
+        return None
+
+
+def get_subjects(grade_level: Optional[str] = None) -> List[Dict[str, Any]]:
+    """
+    Fetch all subjects from Firestore.
+    Falls back to static data if Firestore unavailable.
+    Defaults to Grade 11 (SHS) if no grade specified.
+    """
+    # Default to Grade 11 (SHS) - only serve Grade 11 students for now
+    if grade_level is None:
+        grade_level = "Grade 11"
+    
+    db = _get_firestore_db()
+    
+    if db is not None:
+        try:
+            subjects_ref = db.collection("subjects")
+            if grade_level:
+                subjects_ref = subjects_ref.where("gradeLevel", "==", grade_level)
+            
+            docs = subjects_ref.stream()
+            subjects = []
+            for doc in docs:
+                data = doc.to_dict()
+                if data:
+                    data["id"] = doc.id
+                    subjects.append(data)
+            
+            if subjects:
+                logger.info(f"Loaded {len(subjects)} subjects from Firestore")
+                return subjects
+        except Exception as e:
+            logger.warning(f"Firestore fetch failed, using static data: {e}")
+    
+    # Static fallback
+    if grade_level:
+        return [s for s in _STATIC_SUBJECTS if s.get("gradeLevel") == grade_level]
+    return list(_STATIC_SUBJECTS)
+
+
+def get_subject(subject_id: str) -> Optional[Dict[str, Any]]:
+    """Fetch a single subject by ID."""
+    db = _get_firestore_db()
+    
+    if db is not None:
+        try:
+            doc = db.collection("subjects").document(subject_id).get()
+            if doc.exists:
+                data = doc.to_dict()
+                data["id"] = doc.id
+                return data
+        except Exception as e:
+            logger.warning(f"Firestore fetch failed for {subject_id}: {e}")
+    
+    # Static fallback
+    for subject in _STATIC_SUBJECTS:
+        if subject["id"] == subject_id:
+            return dict(subject)
+    return None
+
+
+def get_topics(subject_id: str) -> List[Dict[str, Any]]:
+    """Fetch all topics for a subject."""
+    subject = get_subject(subject_id)
+    if subject:
+        return subject.get("topics", [])
+    return []
+
+
+def get_topic(subject_id: str, topic_id: str) -> Optional[Dict[str, Any]]:
+    """Fetch a single topic."""
+    topics = get_topics(subject_id)
+    for topic in topics:
+        if topic["id"] == topic_id:
+            return topic
+    return None