added folders

app.py

@@ -0,0 +1,371 @@
+import streamlit as st
+st.set_page_config(
+    page_title="Financial Education App",
+    page_icon="💹",
+    layout="centered",
+    initial_sidebar_state="expanded"
+)
+
+from secrets import choice
+from dashboards import student_db,teacher_db
+from phase.Student_view import chatbot, lesson, quiz, game, teacherlink
+from phase.Teacher_view import classmanage,studentlist,contentmanage
+from phase.Student_view.games import profitpuzzle
+from utils import db,api
+import os, requests
+
+from utils.api import BACKEND
+st.sidebar.caption(f"Backend URL: {BACKEND}")
+
+
+DISABLE_DB = os.getenv("DISABLE_DB", "1") == "1"
+
+try:
+    ok = api.health().get("ok")
+    if ok:
+        st.sidebar.success("Backend: UP")
+    else:
+        st.sidebar.warning("Backend: ?")
+except Exception as e:
+    st.sidebar.error(f"Backend DOWN: {e}")
+
+    
+# --- SESSION STATE INITIALIZATION ---
+for key, default in [("user", None), ("current_page", "Welcome"),
+                     ("xp", 2450), ("streak", 7), ("current_game", None),
+                     ("temp_user", None)]:
+    if key not in st.session_state:
+        st.session_state[key] = default
+
+# --- NAVIGATION ---
+def setup_navigation():
+    if st.session_state.user:
+        public_pages = ["Welcome", "Login"]
+    else:
+        public_pages = ["Welcome", "Signup", "Login"]
+
+    nav_choice = st.sidebar.selectbox(
+        "Go to",
+        public_pages,
+        index=public_pages.index(st.session_state.current_page) if st.session_state.current_page in public_pages else 0
+    )
+
+    # --- if quiz is in progress, show progress tracker ---
+    if st.session_state.get("current_page") == "Quiz":
+        qid = st.session_state.get("selected_quiz")
+        if qid is not None:
+            try:
+                quiz.show_quiz_progress_sidebar(qid)  # renders into sidebar
+            except Exception:
+                pass
+
+        
+    # --- if profit puzzle game is in progress, show progress tracker ---
+    if (
+        st.session_state.get("current_page") == "Game"
+        and st.session_state.get("current_game") == "profit_puzzle"
+    ):
+        profitpuzzle.show_profit_progress_sidebar()
+
+    # Only override if user is already on a public page
+    if st.session_state.current_page in public_pages:
+        st.session_state.current_page = nav_choice
+
+    if st.session_state.user:
+        st.sidebar.markdown("---")
+        st.sidebar.subheader("Dashboard")
+        role = st.session_state.user["role"]
+
+        if role == "Student":
+            if st.sidebar.button("📊 Student Dashboard"):
+                st.session_state.current_page = "Student Dashboard"
+            if st.sidebar.button("📘 Lessons"):
+                st.session_state.current_page = "Lessons"
+            if st.sidebar.button("📝 Quiz"):
+                st.session_state.current_page = "Quiz"
+            if st.sidebar.button("💬 Chatbot"):
+                st.session_state.current_page = "Chatbot"
+            if st.sidebar.button("🏆 Game"):
+                st.session_state.current_page = "Game"
+            if st.sidebar.button("⌨️​ Teacher Link"):
+                st.session_state.current_page = "Teacher Link"
+
+        elif role == "Teacher":
+            if st.sidebar.button("📚 Teacher Dashboard"):
+                st.session_state.current_page = "Teacher Dashboard"
+            if st.sidebar.button("Class management"):
+                st.session_state.current_page = "Class management"
+            if st.sidebar.button("Students List"):
+                st.session_state.current_page = "Students List"
+            if st.sidebar.button("Content Management"):
+                st.session_state.current_page = "Content Management"
+
+        if st.sidebar.button("Logout"):
+            st.session_state.user = None
+            st.session_state.current_page = "Welcome"
+            st.rerun()
+
+
+# --- ROUTING ---
+def main():
+    setup_navigation()
+    page = st.session_state.current_page
+
+    # --- WELCOME PAGE ---
+    if page == "Welcome":
+        st.title("💹 Welcome to FinEdu App")
+        if st.session_state.user:
+            st.success(f"Welcome back, {st.session_state.user['name']}! ✅")
+        st.write(
+            "This app helps you improve your **financial education and numeracy skills**.  \n"
+            "👉 Use the sidebar to **Signup** or **Login** to get started."
+        )
+
+    # --- SIGNUP PAGE ---
+    elif page == "Signup":
+        st.title("📝 Signup")
+
+        # remember the picked role between reruns
+        if "signup_role" not in st.session_state:
+            st.session_state.signup_role = None
+
+        if st.session_state.user:
+            st.success(f"Already logged in as {st.session_state.user['name']}.")
+            st.stop()
+
+        # Step 1: choose role
+        if not st.session_state.signup_role:
+            st.subheader("Who are you signing up as?")
+            c1, c2 = st.columns(2)
+            with c1:
+                if st.button("👩‍🎓 Student", use_container_width=True):
+                    st.session_state.signup_role = "Student"
+                    st.rerun()
+            with c2:
+                if st.button("👨‍🏫 Teacher", use_container_width=True):
+                    st.session_state.signup_role = "Teacher"
+                    st.rerun()
+
+            st.info("Pick your role to continue with the correct form.")
+            st.stop()
+
+        role = st.session_state.signup_role
+
+        # Step 2a: Student form
+        if role == "Student":
+            st.subheader("Student Signup")
+            with st.form("student_signup_form", clear_on_submit=False):
+                name = st.text_input("Full Name")
+                email = st.text_input("Email")
+                password = st.text_input("Password", type="password")
+                country = st.selectbox("Country", ["Jamaica", "USA", "UK", "India", "Canada", "Other"])
+                level = st.selectbox("Level", ["Beginner", "Intermediate", "Advanced"])
+                submitted = st.form_submit_button("Create Student Account")
+
+                if submitted:
+                    if not (name.strip() and email.strip() and password.strip()):
+                        st.error("⚠️ Please complete all required fields.")
+                        st.stop()
+
+                    if DISABLE_DB:
+                        try:
+                            api.signup_student(
+                                name=name.strip(),
+                                email=email.strip().lower(),
+                                password=password,
+                                level_label=level,          # <-- keep these names
+                                country_label=country,
+                            )
+                            st.success("✅ Signup successful! Please go to the **Login** page to continue.")
+                            st.session_state.current_page = "Login"
+                            st.session_state.signup_role = None
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"❌ Signup failed: {e}")
+                    else:
+                        # Local DB path (unchanged)
+                        conn = db.get_db_connection()
+                        if not conn:
+                            st.error("❌ Unable to connect to the database.")
+                            st.stop()
+                        try:
+                            ok = db.create_student(
+                                name=name, email=email, password=password,
+                                level_label=level, country_label=country
+                            )
+                            if ok:
+                                st.success("✅ Signup successful! Please go to the **Login** page to continue.")
+                                st.session_state.current_page = "Login"
+                                st.session_state.signup_role = None
+                                st.rerun()
+                            else:
+                                st.error("❌ Failed to create user. Email may already exist.")
+                        finally:
+                            conn.close()
+
+        # Step 2b: Teacher form
+        elif role == "Teacher":
+            st.subheader("Teacher Signup")
+            with st.form("teacher_signup_form", clear_on_submit=False):
+                title = st.selectbox("Title", ["Mr", "Ms", "Miss", "Mrs", "Dr", "Prof", "Other"])
+                name = st.text_input("Full Name")
+                email = st.text_input("Email")
+                password = st.text_input("Password", type="password")
+                submitted = st.form_submit_button("Create Teacher Account")
+
+                if submitted:
+                    if not (title.strip() and name.strip() and email.strip() and password.strip()):
+                        st.error("⚠️ Please complete all required fields.")
+                        st.stop()
+
+                    if DISABLE_DB:
+                        try:
+                            api.signup_teacher(
+                                title=title.strip(),
+                                name=name.strip(),
+                                email=email.strip().lower(),
+                                password=password,
+                            )
+                            st.success("✅ Signup successful! Please go to the **Login** page to continue.")
+                            st.session_state.current_page = "Login"
+                            st.session_state.signup_role = None
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"❌ Signup failed: {e}")
+                    else:
+                        conn = db.get_db_connection()
+                        if not conn:
+                            st.error("❌ Unable to connect to the database.")
+                            st.stop()
+                        try:
+                            ok = db.create_teacher(
+                                title=title, name=name, email=email, password=password
+                            )
+                            if ok:
+                                st.success("✅ Signup successful! Please go to the **Login** page to continue.")
+                                st.session_state.current_page = "Login"
+                                st.session_state.signup_role = None
+                                st.rerun()
+                            else:
+                                st.error("❌ Failed to create user. Email may already exist.")
+                        finally:
+                            conn.close()
+
+        # Allow changing role without going back manually
+        if st.button("⬅️ Choose a different role"):
+            st.session_state.signup_role = None
+            st.rerun()
+
+    # --- LOGIN PAGE ---
+    elif page == "Login":
+        st.title("🔑 Login")
+        if st.session_state.user:
+            st.success(f"Welcome, {st.session_state.user['name']}! ✅")
+        else:
+            with st.form("login_form"):
+                email = st.text_input("Email")
+                password = st.text_input("Password", type="password")
+                submit = st.form_submit_button("Login")
+
+                if submit:
+                    if DISABLE_DB:
+                        # Route login to your Backend Space
+                        try:
+                            user = api.login(email, password)  # calls POST /auth/login
+                            # Normalize to the structure your app already uses
+                            st.session_state.user = {
+                                "user_id": user["user_id"],
+                                "name": user["name"],
+                                "role": user["role"],   # "Student" or "Teacher" from backend
+                                "email": user["email"],
+                            }
+                            st.success(f"🎉 Logged in as {user['name']} ({user['role']})")
+                            st.session_state.current_page = (
+                                "Student Dashboard" if user["role"] == "Student" else "Teacher Dashboard"
+                            )
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"Login failed. {e}")
+                    else:
+                        # Local fallback: keep your old direct-DB logic
+                        conn = db.get_db_connection()
+                        if not conn:
+                            st.error("❌ Unable to connect to the database.")
+                        else:
+                            try:
+                                user = db.check_password(email, password)
+                                if user:
+                                    st.session_state.user = {
+                                        "user_id": user["user_id"],
+                                        "name": user["name"],
+                                        "role": user["role"],  # "Student" or "Teacher"
+                                        "email": user["email"],
+                                    }
+                                    st.success(f"🎉 Logged in as {user['name']} ({user['role']})")
+                                    st.session_state.current_page = (
+                                        "Student Dashboard" if user["role"] == "Student" else "Teacher Dashboard"
+                                    )
+                                    st.rerun()
+                                else:
+                                    st.error("❌ Incorrect email or password, or account not found.")
+                            finally:
+                                conn.close()
+
+    # --- STUDENT DASHBOARD ---
+    elif page == "Student Dashboard":
+        if not st.session_state.user:
+            st.error("❌ Please login first.")
+            st.session_state.current_page = "Login"
+            st.rerun()
+        elif st.session_state.user["role"] != "Student":
+            st.error("🚫 Only students can access this page.")
+            st.session_state.current_page = "Welcome"
+            st.rerun()
+        else:
+            student_db.show_student_dashboard()
+
+    # --- TEACHER DASHBOARD ---
+    elif page == "Teacher Dashboard":
+        if not st.session_state.user:
+            st.error("❌ Please login first.")
+            st.session_state.current_page = "Login"
+            st.rerun()
+        elif st.session_state.user["role"] != "Teacher":
+            st.error("🚫 Only teachers can access this page.")
+            st.session_state.current_page = "Welcome"
+            st.rerun()
+        else:
+            teacher_db.show_teacher_dashboard()
+
+
+    # --- PRIVATE PAGES ---
+    private_pages_map = {
+        "Lessons": lesson.show_page,
+        "Quiz": quiz.show_page,
+        "Chatbot": chatbot.show_page,
+        "Game": game.show_games,
+        "Teacher Link": teacherlink.show_code,
+        "Class management": classmanage.show_page,
+        "Students List": studentlist.show_page,
+        "Content Management": contentmanage.show_page
+    }
+
+    if page in private_pages_map:
+        if not st.session_state.user:
+            st.error("❌ Please login first.")
+            st.session_state.current_page = "Login"
+            st.rerun()
+        elif page in ["Lessons", "Quiz", "Chatbot", "Game", "Teacher Link"] and st.session_state.user["role"] == "Student":
+            private_pages_map[page]()
+        elif page in ["Class management", "Students List", "Content Management"] and st.session_state.user["role"] == "Teacher":
+            private_pages_map[page]()
+        else:
+            st.error("🚫 You don’t have access to this page.")
+            st.session_state.current_page = "Welcome"
+            st.rerun()
+
+
+
+if __name__ == "__main__":
+    main()
+

assets/styles.css

@@ -0,0 +1,745 @@
+/* -----------------------------------------
+   Google Fonts
+   ----------------------------------------- */
+@import url("https://fonts.googleapis.com/css2?family=Nunito:wght@400;600;700;800&family=Poppins:wght@400;500;600;700&display=swap");
+
+/* -----------------------------------------
+   Design Tokens
+   ----------------------------------------- */
+:root {
+  /* Main container */
+  --main-max-w: 1200px;
+  --main-pt: 2rem; /* default top padding */
+  --main-pb: 0rem; /* default bottom padding */
+  --main-px: 1.25rem;
+
+  /* Colors used throughout (left as-is to preserve your palette) */
+  --brand-green-500: #10b981;
+  --brand-green-600: #059669;
+  --brand-blue-500: #3b82f6;
+  --brand-blue-800: #1e40af;
+  --brand-sky-400: #22d3ee;
+  --brand-emerald-400: #4ade80;
+  --brand-emerald-500: #22c55e;
+  --gray-50: #f9fafb;
+  --gray-100: #f3f4f6;
+  --gray-200: #e5e7eb;
+  --gray-300: #d1d5db;
+  --gray-400: #dee2e6;
+  --gray-500: #6b7280;
+  --gray-600: #605e5c;
+  --gray-700: #495057;
+  --gray-800: #323130;
+  --text-dark: #2c3e50;
+}
+
+/* -----------------------------------------
+   Base / Global
+   ----------------------------------------- */
+
+/* Main container: single source of truth */
+.main .block-container,
+.main > div {
+  max-width: var(--main-max-w);
+  margin: 0 auto;
+  padding: var(--main-pt) var(--main-px) var(--main-pb);
+}
+
+/* Typography */
+h1,
+h2,
+h3 {
+  color: var(--text-dark);
+}
+
+/* Hide Streamlit default elements (kept once) */
+#MainMenu,
+footer,
+header {
+  visibility: hidden;
+}
+
+/* -----------------------------------------
+   Buttons (shared)
+   ----------------------------------------- */
+.stButton > button {
+  border-radius: 8px;
+  border: none;
+  font-weight: 600;
+  transition: all 0.3s ease;
+  background: var(--brand-green-500);
+  color: #fff;
+  padding: 0.5rem 1rem;
+}
+
+.stButton > button:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+  background: var(--brand-green-600);
+}
+
+/* Light gray styling for review buttons - multiple targets preserved */
+.stButton > button:has-text("Review"),
+.stButton > button[aria-label*="Review"],
+div[data-testid*="lesson_review"] button {
+  background-color: #f8f9fa !important;
+  color: #6c757d !important;
+  border: 1px solid #dee2e6 !important;
+}
+
+.stButton > button:has-text("Review"):hover,
+.stButton > button[aria-label*="Review"]:hover,
+div[data-testid*="lesson_review"] button:hover {
+  background-color: #e9ecef !important;
+  color: #495057 !important;
+  transform: translateY(-1px);
+}
+
+button[kind="secondary"] {
+  background-color: #f8f9fa !important;
+  color: #6c757d !important;
+  border: 1px solid #dee2e6 !important;
+}
+button[kind="secondary"]:hover {
+  background-color: #e9ecef !important;
+  color: #495057 !important;
+}
+
+/* -----------------------------------------
+   Welcome Card
+   ----------------------------------------- */
+.welcome-card {
+  background: linear-gradient(to right, #4ade80, #22d3ee);
+  padding: 2rem;
+  border-radius: 15px;
+  color: white;
+  text-align: center;
+  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+.welcome-btn {
+  background: #fff;
+  color: #111;
+  padding: 10px 20px;
+  border-radius: 8px;
+  border: none;
+  font-weight: bold;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+.welcome-btn:hover {
+  background: #e0e0e0;
+}
+
+/* -----------------------------------------
+   XP Card
+   ----------------------------------------- */
+.xp-card {
+  background: var(--brand-blue-500);
+  padding: 1rem;
+  border-radius: 12px;
+  color: white;
+  position: relative;
+  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+.xp-level {
+  font-weight: bold;
+  color: #0b612a;
+}
+.xp-text {
+  position: absolute;
+  right: 1rem;
+  top: 1rem;
+}
+.xp-bar {
+  background: var(--brand-blue-800);
+  height: 12px;
+  border-radius: 8px;
+  margin-top: 0.5rem;
+}
+.xp-fill {
+  background: var(--brand-emerald-500);
+  height: 12px;
+  border-radius: 8px;
+  transition: width 0.3s ease-in-out;
+}
+
+/* -----------------------------------------
+   Daily Challenge
+   ----------------------------------------- */
+.challenge-card {
+  background: linear-gradient(135deg, #d946ef, #ec4899);
+  padding: 1.5rem;
+  border-radius: 12px;
+  color: white;
+  position: relative;
+  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+.challenge-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+.challenge-difficulty {
+  background: rgba(255, 255, 255, 0.2);
+  padding: 0.2rem 0.8rem;
+  border-radius: 12px;
+  font-size: 0.85rem;
+}
+.challenge-progress {
+  background: rgba(255, 255, 255, 0.3);
+  height: 10px;
+  border-radius: 8px;
+  margin: 1rem 0;
+}
+.challenge-fill {
+  background: var(--brand-emerald-500);
+  height: 10px;
+  border-radius: 8px;
+  transition: width 0.3s ease-in-out;
+}
+.challenge-percent {
+  position: absolute;
+  right: 1.5rem;
+  top: 7rem;
+}
+.challenge-footer {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-top: 1rem;
+}
+.challenge-btn {
+  background: rgba(255, 255, 255, 0.2);
+  border: none;
+  padding: 0.5rem 1rem;
+  border-radius: 8px;
+  color: white;
+  font-weight: bold;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+.challenge-btn:hover {
+  background: rgba(255, 255, 255, 0.3);
+}
+
+/* -----------------------------------------
+   Game Card
+   ----------------------------------------- */
+.game-card {
+  background: #ffffff;
+  padding: 1.5rem;
+  border-radius: 12px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+  text-align: center;
+}
+.game-card img {
+  margin-bottom: 1rem;
+}
+.game-difficulty {
+  background-color: lightgray;
+  padding: 5px;
+  border-radius: 5px;
+  display: inline-block;
+}
+.game-difficulty.easy {
+  background-color: lightgreen;
+}
+.game-difficulty.medium {
+  background-color: #ffb347;
+}
+.game-difficulty.hard {
+  background-color: lightcoral;
+}
+.game-btn {
+  background: #10b981;
+  color: white;
+  padding: 10px 20px;
+  border: none;
+  border-radius: 8px;
+  font-weight: bold;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+.game-btn:hover {
+  background: #059669;
+}
+
+/* -----------------------------------------
+   Leaderboard
+   ----------------------------------------- */
+.leaderboard-card {
+  background: var(--gray-50);
+  padding: 1.5rem;
+  border-radius: 12px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+.leaderboard-item {
+  margin-bottom: 0.5rem;
+}
+.leaderboard-you {
+  color: var(--brand-green-500);
+  font-weight: bold;
+}
+
+/* -----------------------------------------
+   Tips
+   ----------------------------------------- */
+.tips-card {
+  background: var(--gray-50);
+  padding: 1.5rem;
+  border-radius: 12px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+.tips-item {
+  margin-bottom: 0.5rem;
+}
+
+/* -----------------------------------------
+   lesson.py CSS
+   ----------------------------------------- */
+.stMetric {
+  background-color: #f8f9fa;
+  padding: 1rem;
+  border-radius: 8px;
+  border-left: 4px solid #007bff;
+}
+.stProgress > div > div {
+  background-color: #007bff;
+}
+
+.lesson-card {
+  transition: all 0.3s ease;
+  cursor: pointer;
+}
+.lesson-card:hover {
+  transform: translateY(-4px) !important;
+  box-shadow: 0 8px 16px rgba(0, 0, 0, 0.15) !important;
+  border-color: #0078d4 !important;
+}
+
+.topic-content {
+  font-size: 1.25rem;
+  line-height: 1.8;
+  padding: 1.5rem;
+  background: #fffef5;
+  border-radius: 16px;
+  border: 2px solid #f0e68c;
+  margin-bottom: 1.5rem;
+  font-family: "Comic Sans MS", "Segoe UI", Arial, sans-serif;
+}
+.topic-content p {
+  margin-bottom: 1rem;
+}
+.topic-content ul,
+.topic-content ol {
+  padding-left: 1.5rem;
+  margin-bottom: 1rem;
+}
+
+/* buttons */
+.topic-nav-btn button {
+  font-size: 1.3rem;
+  font-weight: 600;
+  padding: 1rem;
+  border-radius: 999px;
+  transition: all 0.2s ease-in-out;
+  border: none;
+  width: 100%;
+  height: 3.5rem;
+}
+/* Previous button (pink, left) */
+.prev-btn button {
+  background-color: #ff99cc !important;
+  color: white !important;
+  text-align: left;
+}
+/* Next button (blue, right) */
+.next-btn button {
+  background-color: #66ccff !important;
+  color: white !important;
+  text-align: right;
+}
+.topic-nav-btn button:hover {
+  transform: scale(1.05);
+  opacity: 0.9;
+}
+
+/* -----------------------------------------
+   code.py
+   ----------------------------------------- */
+.join-class-container {
+  max-width: 600px;
+  margin: 2rem auto;
+  padding: 0 1rem;
+}
+.header-text {
+  text-align: center;
+  color: #605e5c;
+  font-size: 18px;
+  margin-bottom: 2rem;
+  line-height: 1.5;
+}
+.join-card {
+  background: white;
+  border: 1px solid #e1e5e9;
+  border-radius: 12px;
+  padding: 2rem;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+  margin-bottom: 1rem;
+}
+.card-header {
+  display: flex;
+  align-items: center;
+  margin-bottom: 1rem;
+}
+.card-icon {
+  font-size: 24px;
+  margin-right: 12px;
+  color: #323130;
+}
+.card-title {
+  font-size: 24px;
+  font-weight: 600;
+  color: #323130;
+  margin: 0;
+}
+.card-subtitle {
+  color: #605e5c;
+  font-size: 16px;
+  margin-bottom: 1.5rem;
+  line-height: 1.4;
+}
+.input-container {
+  margin-bottom: 1.5rem;
+}
+.footer-text {
+  text-align: center;
+  color: #605e5c;
+  font-size: 14px;
+  margin-top: 1rem;
+  line-height: 1.4;
+}
+.stTextInput > div > div > input {
+  border-radius: 8px;
+  border: 1px solid #d1d5db;
+  padding: 12px 16px;
+  font-size: 16px;
+}
+.stTextInput > div > div > input:focus {
+  border-color: #0078d4;
+  box-shadow: 0 0 0 2px rgba(0, 120, 212, 0.2);
+}
+
+/* -----------------------------------------
+   Teacher Dashboard
+   ----------------------------------------- */
+
+/* Header styling with gradient */
+.header-container {
+  background: linear-gradient(135deg, #10b981 0%, #059669 100%);
+  padding: 2rem;
+  border-radius: 1rem;
+  margin-bottom: 2rem;
+  color: white;
+  position: relative;
+}
+.header-content {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  width: 100%;
+}
+.header-left {
+  flex: 1;
+}
+.header-title {
+  font-size: 2rem;
+  font-weight: 700;
+  margin-bottom: 0.5rem;
+  color: white;
+}
+.header-subtitle {
+  font-size: 1.1rem;
+  opacity: 0.9;
+  color: white;
+}
+
+/* Metric cards (dashboard version) */
+.metric-card {
+  background: white;
+  padding: 1.5rem;
+  border-radius: 1rem;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  border: 1px solid #f3f4f6;
+  text-align: center;
+  margin-bottom: 1rem;
+}
+.metric-icon {
+  font-size: 2rem;
+  color: var(--brand-green-500);
+}
+.metric-value {
+  font-size: 2rem;
+  font-weight: 700;
+  color: var(--brand-green-500);
+}
+.metric-label {
+  font-size: 0.9rem;
+  color: #6b7280;
+  font-weight: 500;
+}
+
+/* Chart containers */
+.chart-title {
+  font-size: 1.25rem;
+  font-weight: 600;
+  color: #1f2937;
+}
+
+/* Progress bars */
+.progress-label {
+  font-size: 0.9rem;
+  color: #6b7280;
+}
+
+/* Activity section */
+.activity-item {
+  padding: 0.75rem;
+  background: #f9fafb;
+  border-radius: 0.5rem;
+  margin-bottom: 0.5rem;
+  border-left: 3px solid var(--brand-green-500);
+}
+
+/* Quick actions */
+.quick-action-btn {
+  width: 100%;
+  margin-bottom: 0.5rem;
+  background: #f3f4f6;
+  border: none;
+  padding: 0.75rem;
+  border-radius: 0.5rem;
+  text-align: left;
+  font-weight: 500;
+}
+.quick-action-btn:hover {
+  background: #e5e7eb;
+}
+
+.main .block-container {
+  padding-top: 4rem;
+  padding-bottom: 0rem;
+}
+
+/* -----------------------------------------
+   Debt Dilemma (Game)
+   ----------------------------------------- */
+.game-header {
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  padding: 1.5rem;
+  border-radius: 15px;
+  color: white;
+  text-align: center;
+  margin-bottom: 2rem;
+  box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
+}
+.game-title {
+  font-size: 2.5rem;
+  font-weight: bold;
+  margin-bottom: 0.5rem;
+  text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
+}
+
+.metric-card {
+  background: white;
+  padding: 1rem;
+  border-radius: 8px;
+  text-align: center;
+  margin: 0.5rem 0;
+  border: 1px solid #e0e0e0;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+}
+.metric-card h2,
+.metric-card h3,
+.metric-card h4 {
+  margin: 0.25rem 0;
+  color: #333;
+}
+.metric-card small {
+  color: #666;
+}
+
+.stButton > button:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 6px 20px rgba(0, 0, 0, 0.3);
+}
+.success-btn > button {
+  background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%) !important;
+}
+.warning-btn > button {
+  background: linear-gradient(135deg, #fa709a 0%, #fee140 100%) !important;
+}
+.danger-btn > button {
+  background: linear-gradient(135deg, #ff6b6b 0%, #ffa500 100%) !important;
+}
+.event-card {
+  background: #f8f9fa;
+  color: #333;
+  padding: 1.5rem;
+  border-radius: 8px;
+  margin: 1rem 0;
+  border: 1px solid #dee2e6;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+}
+.event-title {
+  font-size: 1.5rem;
+  font-weight: bold;
+  margin-bottom: 0.5rem;
+  color: #495057;
+}
+.expense-card {
+  background: white;
+  padding: 1rem;
+  border-radius: 8px;
+  margin: 0.5rem 0;
+  border: 1px solid #e0e0e0;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.05);
+}
+.expense-card h4 {
+  margin: 0 0 0.5rem 0;
+  color: #333;
+}
+.expense-card p {
+  margin: 0.25rem 0;
+  color: #666;
+}
+.achievement-badge {
+  background: #f8f9fa;
+  padding: 0.5rem 1rem;
+  border-radius: 20px;
+  margin: 0.25rem;
+  display: inline-block;
+  font-weight: bold;
+  border: 1px solid #dee2e6;
+  color: #495057;
+}
+.stProgress > div > div > div {
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  border-radius: 10px;
+}
+.stAlert {
+  border-radius: 8px;
+  border: none;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+}
+
+/* ---------- Leaderboard styles ---------- */
+.leaderboard {
+  --lb-bg: #ffffff;
+  --lb-border: #e5e7eb; /* gray-200 */
+  --lb-accent: linear-gradient(135deg, #22c55e, #059669);
+  --lb-you-bg: #ecfdf5; /* emerald-50 */
+  --lb-text: #111827; /* gray-900 */
+
+  border: 1px solid var(--lb-border);
+  border-radius: 16px;
+  background: var(--lb-bg);
+  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.06);
+  overflow: hidden;
+  color: var(--lb-text);
+}
+
+.leaderboard .lb-head {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 14px 18px;
+  background: var(--lb-accent);
+  color: #fff;
+  font-weight: 800;
+  letter-spacing: 0.2px;
+}
+
+.lb-row {
+  display: grid;
+  grid-template-columns: 56px 1fr auto auto;
+  gap: 12px;
+  align-items: center;
+  padding: 12px 18px;
+  border-top: 1px solid var(--lb-border);
+}
+
+.lb-row:first-of-type {
+  border-top: none;
+}
+
+.lb-row.is-you {
+  background: var(--lb-you-bg);
+  position: relative;
+}
+
+.lb-rank {
+  width: 36px;
+  height: 36px;
+  display: grid;
+  place-items: center;
+  border-radius: 12px;
+  background: #f3f4f6; /* gray-100 */
+  font-weight: 800;
+}
+
+.lb-rank.medal-1 {
+  background: #f59e0b;
+  color: #fff;
+} /* gold */
+.lb-rank.medal-2 {
+  background: #9ca3af;
+  color: #fff;
+} /* silver */
+.lb-rank.medal-3 {
+  background: #b45309;
+  color: #fff;
+} /* bronze */
+
+.lb-name {
+  font-weight: 700;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.lb-level {
+  font-size: 12px;
+  padding: 4px 10px;
+  border-radius: 999px;
+  background: #eef2ff; /* indigo-50 */
+  color: #3730a3; /* indigo-800 */
+  font-weight: 800;
+}
+
+.lb-xp {
+  font-variant-numeric: tabular-nums;
+  font-weight: 700;
+}
+
+.lb-you-pill {
+  position: absolute;
+  right: 10px;
+  top: 10px;
+  background: #10b981; /* emerald-500 */
+  color: #fff;
+  font-size: 11px;
+  padding: 2px 8px;
+  border-radius: 999px;
+  font-weight: 800;
+}
+
+/* Small screens: tuck columns a bit tighter */
+@media (max-width: 640px) {
+  .lb-row {
+    grid-template-columns: 48px 1fr auto;
+  }
+  .lb-xp {
+    display: none; /* hide XP column on very small screens */
+  }
+}

dashboards/student_db.py

@@ -0,0 +1,240 @@
+import os
+import streamlit as st
+from phase.Student_view import chatbot, lesson, quiz
+from utils import db as dbapi
+import utils.api as api  # <-- backend Space client
+
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
+
+# --- Load external CSS ---
+def load_css(file_name: str):
+    try:
+        with open(file_name, "r", encoding="utf-8") as f:
+            st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+    except FileNotFoundError:
+        st.warning("⚠️ Stylesheet not found. Please ensure 'assets/styles.css' exists.")
+
+def show_student_dashboard():
+    # Load CSS
+    css_path = os.path.join("assets", "styles.css")
+    load_css(css_path)
+
+    # Current user
+    user = st.session_state.user
+    name = user["name"]
+    student_id = user["user_id"]
+
+    # --- Real metrics from DB ---
+    # Requires helper funcs in utils/db.py: user_xp_and_level, recent_lessons_for_student, list_assignments_for_student
+    if USE_LOCAL_DB and hasattr(dbapi, "user_xp_and_level"):
+        stats = dbapi.user_xp_and_level(student_id)
+    else:
+         # Try backend; fall back to defaults if not available yet
+        try:
+             stats = api.user_stats(student_id)
+        except Exception:
+             stats = {"xp": 0, "level": 1, "streak": 0}
+
+    xp = int(stats.get("xp", 0))
+    level = int(stats.get("level", 1))
+    study_streak = int(stats.get("streak", 0))
+
+    # # Cap for the visual bar
+    # max_xp = max(500, ((xp // 500) + 1) * 500)
+
+    # Assignments for “My Work”
+    if USE_LOCAL_DB and hasattr(dbapi, "list_assignments_for_student"):
+       rows = dbapi.list_assignments_for_student(student_id)
+    else:
+        try:
+           rows = api.list_assignments_for_student(student_id)
+        except Exception:
+            rows = []
+
+    def _pct_from_row(r: dict):
+        sp = r.get("score_pct")
+        if sp is not None:
+            try:
+                return int(round(float(sp)))
+            except Exception:
+                pass
+        s, t = r.get("score"), r.get("total")
+        if s is not None and t not in (None, 0):
+            try:
+                return int(round((float(s) / float(t)) * 100))
+            except Exception:
+                return None
+        return None
+
+    if USE_LOCAL_DB and hasattr(dbapi, "student_quiz_average"):
+        quiz_score = dbapi.student_quiz_average(student_id)
+    else:
+        try:
+            quiz_score = api.student_quiz_average(student_id)
+        except Exception:
+            quiz_score = 0
+
+    lessons_completed = sum(1 for r in rows if r.get("status") == "completed" or _pct_from_row(r) == 100)
+    total_lessons = len(rows)
+
+    # Recent lessons assigned to this student
+    if USE_LOCAL_DB and hasattr(dbapi, "recent_lessons_for_student"):
+        recent_lessons = dbapi.recent_lessons_for_student(student_id, limit=5)
+    else:
+        try:
+            recent_lessons = api.recent_lessons_for_student(student_id, limit=5)
+        except Exception:
+            recent_lessons = []
+
+    # Daily Challenge derived from real data
+    challenge_difficulty = "Easy" if level < 3 else ("Medium" if level < 6 else "Hard")
+    challenge_title = "Complete 1 quiz with 80%+"
+    challenge_desc = "Prove you remember yesterday's key points."
+    challenge_progress = 100 if quiz_score >= 80 else 0
+    reward = "+50 XP"
+    time_left = "Ends 11:59 PM"
+
+    # Achievements from real data
+    achievements = [
+        {"title": "First Steps", "desc": "Complete your first lesson", "earned": lessons_completed > 0},
+        {"title": "Quiz Whiz", "desc": "Score 80%+ on any quiz", "earned": quiz_score >= 80},
+        {"title": "On a Roll", "desc": "Study 3 days in a row", "earned": study_streak >= 3},
+        {"title": "Consistency", "desc": "Finish 5 assignments", "earned": total_lessons >= 5 and lessons_completed >= 5},
+    ]
+
+    # --- Welcome Card ---
+    st.markdown(
+        f"""
+        <div class="welcome-card">
+            <h2>Welcome back, {name}!</h2>
+            <p style="font-size: 20px;">{"Ready to continue your financial journey?" if lessons_completed > 0 else "Start your financial journey."}</p>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+    st.write("")
+
+    # --- Quick Action Buttons ---
+    actions = [
+        ("📚 Start a Lesson", "Lessons"),
+        ("📝 Attempt a Quiz", "Quiz"),
+        ("💬 Talk to AI Tutor", "Chatbot"),
+    ]
+
+    # 5 columns: spacer, button, button, button, spacer
+    cols = st.columns([1, 2, 2, 2, 1])
+    for i, (label, page) in enumerate(actions):
+        with cols[i+1]:  # skip the left spacer
+            if st.button(label, key=f"action_{i}"):
+                st.session_state.current_page = page
+                st.rerun()
+
+    st.write("")
+
+    # --- Progress Summary Cards ---
+    progress_cols = st.columns(3)
+    progress_cols[0].metric("📘 Lessons Completed", f"{lessons_completed}/{total_lessons}")
+    progress_cols[1].metric("📊 Quiz Score", f"{quiz_score}/100")
+    progress_cols[2].metric("🔥 Study Streak", f"{study_streak} days")
+    st.write("")
+
+        # --- XP Bar ---
+    # stats already fetched above
+    xp = int(stats.get("xp", 0))
+    level = int(stats.get("level", 1))
+    study_streak = int(stats.get("streak", 0))
+
+    # prefer server-provided per-level fields
+    into = int(stats.get("into", -1))
+    need = int(stats.get("need", -1))
+
+    # fallback if backend hasn't been updated to include into/need yet
+    if into < 0 or need <= 0:
+        base = 500
+        level = max(1, xp // base + 1)
+        start = (level - 1) * base
+        into = xp - start
+        need = base
+        if into == need:
+            level += 1
+            into = 0
+
+    cap = max(500, ((xp // 500) + 1) * 500)        # next threshold
+    pct = 0 if cap <= 0 else min(100, int(round(100 * xp / cap)))
+
+    st.markdown(
+        f"""
+        <div class="xp-card">
+            <span class="xp-level">Level {level}</span>
+            <span class="xp-text">{xp:,} / {cap:,} XP</span>
+            <div class="xp-bar">
+                <div class="xp-fill" style="width: {pct}%;"></div>
+            </div>
+            <div class="xp-total">Total XP: {xp:,}</div>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+    # pct = 0 if max_xp <= 0 else min(100, int(round((xp / max_xp) * 100)))
+    # st.markdown(
+    #     f"""
+    #     <div class="xp-card">
+    #         <span class="xp-level">Level {level}</span>
+    #         <span class="xp-text">{xp} / {max_xp} XP</span>
+    #         <div class="xp-bar">
+    #             <div class="xp-fill" style="width: {pct}%;"></div>
+    #         </div>
+    #     </div>
+    #     """,
+    #     unsafe_allow_html=True
+    # )
+    # st.write("")
+
+# --- My Assignments (from DB) ---
+    st.markdown("---")
+    st.subheader("📘 My Work")
+    if not rows:
+        st.info("No assignments yet. Ask your teacher to assign a lesson.")
+    else:
+        for a in rows:
+            title  = a.get("title", "Untitled")
+            subj   = a.get("subject", "General")
+            lvl    = a.get("level", "Beginner")
+            status = a.get("status", "not_started")
+            due    = a.get("due_at")
+            due_txt = f" · Due {str(due)[:10]}" if due else ""
+            st.markdown(f"**{title}** · {subj} · {lvl}{due_txt}")
+            st.caption(f"Status: {status}  ·  Resume at section {a.get('current_pos', 1)}")
+            st.markdown("---")
+
+    # --- Recent Lessons & Achievements ---
+    col1, col2 = st.columns(2)
+
+    def _progress_value(v):
+        try:
+            f = float(v)
+        except Exception:
+            return 0.0
+        # streamlit accepts 0–1 float; if someone passes 0–100, scale it
+        return max(0.0, min(1.0, f if f <= 1.0 else f / 100.0))
+
+    with col1:
+        st.subheader("📖 Recent Lessons")
+        st.caption("Continue where you left off")
+        if not recent_lessons:
+            st.info("No recent lessons yet.")
+        else:
+            for lesson in recent_lessons:
+                prog = lesson.get("progress", 0)
+                st.progress(_progress_value(prog))
+                status = "✅ Complete" if (isinstance(prog, (int, float)) and prog >= 100) else f"{int(prog)}% complete"
+                st.write(f"**{lesson.get('title','Untitled Lesson')}** — {status}")
+
+    with col2:
+        st.subheader("🏆 Achievements")
+        st.caption("Your learning milestones")
+        for ach in achievements:
+            if ach["earned"]:
+                st.success(f"✔ {ach['title']} — {ach['desc']}")
+            else:
+                st.info(f"🔒 {ach['title']} — {ach['desc']}")

dashboards/teacher_db.py

@@ -0,0 +1,294 @@
+# dashboards/teacher_db.py
+import os
+import io
+import csv
+import datetime
+import streamlit as st
+import plotly.graph_objects as go
+
+from utils import db as dbapi
+import utils.api as api  # backend Space client
+
+# If DISABLE_DB=1 (default), don't call MySQL at all
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
+
+def load_css(file_name):
+    try:
+        with open(file_name, 'r', encoding="utf-8") as f:
+            st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+    except FileNotFoundError:
+        st.warning("⚠️ Stylesheet not found. Please ensure 'assets/styles.css' exists.")
+
+def tile(icon, label, value):
+    return f"""
+    <div class="metric-card">
+      <div class="metric-icon">{icon}</div>
+      <div class="metric-value">{value}</div>
+      <div class="metric-label">{label}</div>
+    </div>
+    """
+
+def _level_from_xp(xp: int) -> int:
+    """
+    Prefer backend/db helper if available, else simple fallback (every 500 XP = +1 level).
+    """
+    try:
+        if USE_LOCAL_DB and hasattr(dbapi, "level_from_xp"):
+            return int(dbapi.level_from_xp(xp))
+        if hasattr(api, "level_from_xp"):  # if you add the endpoint
+            return int(api.level_from_xp(int(xp)))
+    except Exception:
+        pass
+    xp = int(xp or 0)
+    return 1 + (xp // 500)
+
+def _safe_get_tiles(teacher_id: int) -> dict:
+    if USE_LOCAL_DB and hasattr(dbapi, "teacher_tiles"):
+        return dbapi.teacher_tiles(teacher_id)
+    try:
+        return api.teacher_tiles(teacher_id)
+    except Exception:
+        return {
+            "total_students": 0, "class_avg": 0.0,
+            "lessons_created": 0, "active_students": 0
+        }
+
+def _safe_list_classes(teacher_id: int) -> list:
+    if USE_LOCAL_DB and hasattr(dbapi, "list_classes_by_teacher"):
+        return dbapi.list_classes_by_teacher(teacher_id)
+    try:
+        return api.list_classes_by_teacher(teacher_id)
+    except Exception:
+        return []
+
+def _safe_create_class(teacher_id: int, name: str) -> dict:
+    if USE_LOCAL_DB and hasattr(dbapi, "create_class"):
+        return dbapi.create_class(teacher_id, name)
+    return api.create_class(teacher_id, name)
+
+def _safe_class_student_metrics(class_id: int) -> list:
+    if USE_LOCAL_DB and hasattr(dbapi, "class_student_metrics"):
+        return dbapi.class_student_metrics(class_id)
+    try:
+        return api.class_student_metrics(class_id)
+    except Exception:
+        return []
+
+def _safe_weekly_activity(class_id: int) -> list:
+    if USE_LOCAL_DB and hasattr(dbapi, "class_weekly_activity"):
+        return dbapi.class_weekly_activity(class_id)
+    try:
+        return api.class_weekly_activity(class_id)
+    except Exception:
+        return []
+
+def _safe_progress_overview(class_id: int) -> dict:
+    if USE_LOCAL_DB and hasattr(dbapi, "class_progress_overview"):
+        return dbapi.class_progress_overview(class_id)
+    try:
+        return api.class_progress_overview(class_id)
+    except Exception:
+        return {
+            "overall_progress": 0.0, "quiz_performance": 0.0,
+            "lessons_completed": 0, "class_xp": 0
+        }
+
+def _safe_recent_activity(class_id: int, limit=6, days=30) -> list:
+    if USE_LOCAL_DB and hasattr(dbapi, "class_recent_activity"):
+        return dbapi.class_recent_activity(class_id, limit=limit, days=days)
+    try:
+        return api.class_recent_activity(class_id, limit=limit, days=days)
+    except Exception:
+        return []
+
+def _safe_list_students(class_id: int) -> list:
+    if USE_LOCAL_DB and hasattr(dbapi, "list_students_in_class"):
+        return dbapi.list_students_in_class(class_id)
+    try:
+        return api.list_students_in_class(class_id)
+    except Exception:
+        return []
+
+def show_teacher_dashboard():
+    css_path = os.path.join("assets", "styles.css")
+    load_css(css_path)
+
+    user = st.session_state.user
+    teacher_id = user["user_id"]
+    name = user["name"]
+
+    # ========== HEADER / HERO ==========
+    colH1, colH2 = st.columns([5, 2])
+    with colH1:
+        st.markdown(f"""
+            <div class="header-container">
+              <div class="header-content">
+                <div class="header-left">
+                  <div class="header-title">Welcome back, Teacher {name}!</div>
+                  <div class="header-subtitle">Managing your classrooms</div>
+                </div>
+              </div>
+            </div>
+        """, unsafe_allow_html=True)
+    with colH2:
+        with st.popover("➕ Create Classroom"):
+            new_class_name = st.text_input("Classroom Name", key="new_class_name")
+            if st.button("Create Classroom", key="create_classroom_btn"):
+                if new_class_name.strip():
+                    try:
+                        out = _safe_create_class(teacher_id, new_class_name.strip())
+                        code = out.get("code") or out.get("class_code") or "—"
+                        st.success(f"Classroom created. Code: **{code}**")
+                    except Exception as e:
+                        st.error(f"Create failed: {e}")
+
+    # ========== TILES ==========
+    tiles = _safe_get_tiles(teacher_id)
+    c1,c2,c3,c4 = st.columns(4)
+    c1.markdown(tile("👥","Total Students", tiles.get("total_students", 0)), unsafe_allow_html=True)
+    c2.markdown(tile("📊","Class Average", f"{int((tiles.get('class_avg') or 0)*100)}%"), unsafe_allow_html=True)
+    c3.markdown(tile("📚","Lessons Created", tiles.get("lessons_created", 0)), unsafe_allow_html=True)
+    c4.markdown(tile("📈","Active Students", tiles.get("active_students", 0)), unsafe_allow_html=True)
+
+    # ========== CLASS PICKER ==========
+    classes = _safe_list_classes(teacher_id)
+    if not classes:
+        st.info("No classes yet. Create one above, then share the code with students.")
+        return
+
+    idx = st.selectbox(
+        "Choose a class",
+        list(range(len(classes))),
+        index=0,
+        format_func=lambda i: f"{classes[i].get('name','Class')} (Code: {classes[i].get('code','')})"
+    )
+    selected = classes[idx]
+    class_id = selected.get("class_id") or selected.get("id")
+    class_code = selected.get("code","")
+
+    # secondary hero controls
+    cTop1, cTop2, cTop3 = st.columns([2,1,1])
+    with cTop1:
+        st.button(f"Class Code: {class_code}", disabled=True)
+    with cTop2:
+        if st.button("📋 Copy Code"):
+            st.toast("Code copied. Paste it anywhere your heart desires.")
+    with cTop3:
+        rows = _safe_class_student_metrics(class_id)
+        if rows:
+            headers = []
+            for r in rows:
+                for k in r.keys():
+                    if k not in headers:
+                        headers.append(k)
+            buf = io.StringIO()
+            writer = csv.DictWriter(buf, fieldnames=headers)
+            writer.writeheader()
+            for r in rows:
+                writer.writerow(r)
+            st.download_button(
+                "📤 Export Class Report",
+                data=buf.getvalue(),
+                file_name=f"class_{class_id}_report.csv",
+                mime="text/csv"
+            )
+        else:
+            st.button("📤 Export Class Report", disabled=True)
+
+    # ========== TOP ROW: WEEKLY ACTIVITY + CLASS PROGRESS ==========
+    left, right = st.columns([3,2])
+
+    with left:
+        st.subheader("Weekly Activity")
+        st.caption("Student engagement throughout the week")
+        activity = _safe_weekly_activity(class_id)
+        if activity:
+            days, lessons, quizzes, games = [], [], [], []
+            for row in activity:
+                date_str = row.get("date")
+                try:
+                    # Support ISO date or datetime
+                    day = datetime.datetime.fromisoformat(str(date_str)).strftime("%a")
+                except Exception:
+                    day = str(date_str)
+                days.append(day)
+                lessons.append(row.get("lessons",0))
+                quizzes.append(row.get("quizzes",0))
+                games.append(row.get("games",0))
+            fig = go.Figure(data=[
+                go.Bar(name="Lessons", x=days, y=lessons),
+                go.Bar(name="Quizzes", x=days, y=quizzes),
+                go.Bar(name="Games", x=days, y=games),
+            ])
+            fig.update_layout(barmode="group", xaxis_title="Day", yaxis_title="Count")
+            st.plotly_chart(fig, use_container_width=True)
+        else:
+            st.info("No activity in the last 7 days.")
+
+    with right:
+        st.subheader("Class Progress Overview")
+        st.caption("How your students are performing")
+
+        prog = _safe_progress_overview(class_id)
+        overall_pct = int(round((prog.get("overall_progress") or 0) * 100))
+        quiz_pct    = int(round((prog.get("quiz_performance") or 0) * 100))
+
+        st.text("Overall Progress")
+        st.progress(min(1.0, overall_pct/100.0))
+        st.caption(f"{overall_pct}%")
+
+        st.text("Quiz Performance")
+        st.progress(min(1.0, quiz_pct/100.0))
+        st.caption(f"{quiz_pct}%")
+
+        k1, k2 = st.columns(2)
+        k1.metric("📖 Lessons Completed", prog.get("lessons_completed", 0))
+        k2.metric("🪙 Total Class XP",    prog.get("class_xp", 0))
+
+    # ========== BOTTOM ROW: RECENT ACTIVITY + QUICK ACTIONS ==========
+    b1, b2 = st.columns([3,2])
+
+    with b1:
+        st.subheader("Recent Student Activity")
+        st.caption("Latest activity from your students")
+        feed = _safe_recent_activity(class_id, limit=6, days=30)
+        if not feed:
+            st.caption("Nothing yet. Assign something, chief.")
+        else:
+            for r in feed:
+                kind = str(r.get("kind","")).lower()
+                icon = "📘" if kind == "lesson" else "🏆" if kind == "quiz" else "🎮"
+                lvl = r.get("level") or _level_from_xp(r.get("total_xp", 0))
+                tail = f" · {r['extra']}" if r.get("extra") else ""
+                st.write(f"{icon} **{r.get('student_name','(unknown)')}** — {r.get('item_title','(untitled)')}{tail}  \n"
+                         f"*Level {lvl}*")
+
+    with b2:
+        st.subheader("Quick Actions")
+        st.caption("Manage your classroom")
+        if st.button("📖 Create New Lesson", use_container_width=True):
+            st.session_state.current_page = "Content Management"
+            st.rerun()
+        if st.button("🏆 Create New Quiz", use_container_width=True):
+            st.session_state.current_page = "Content Management"
+            st.rerun()
+        if st.button("🗓️ Schedule Assignment", use_container_width=True):
+            st.session_state.current_page = "Class management"
+            st.rerun()
+        if st.button("📄 Generate Reports", use_container_width=True):
+            st.session_state.current_page = "Students List"
+            st.rerun()
+
+    # optional: keep your per-class expanders below
+    for c in classes:
+        with st.expander(f"{c.get('name','Class')}  · Code **{c.get('code','')}**"):
+            st.write(f"Students: {c.get('total_students', 0)}")
+            avg = c.get("class_avg", 0.0)
+            st.write(f"Average score: {round(float(avg)*100) if avg is not None else 0}%")
+            roster = _safe_list_students(c.get("class_id") or c.get("id"))
+            if roster:
+                for s in roster:
+                    lvl_slug = (s.get("level_slug") or s.get("level") or "beginner")
+                    st.write(f"- {s.get('name','(unknown)')} · {s.get('email','—')} · Level {str(lvl_slug).capitalize()}")
+            else:
+                st.caption("No students yet. Share the code.")

isrgrootx1.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

phase/Student_view/chatbot.py

@@ -0,0 +1,215 @@
+# phase/Student_view/chatbot.py
+import streamlit as st
+import datetime, os, traceback
+from huggingface_hub import InferenceClient
+
+HF_TOKEN = os.getenv("HF_TOKEN")
+GEN_MODEL = os.getenv("GEN_MODEL", "TinyLlama/TinyLlama-1.1B-Chat-v1.0")  # <- default TinyLlama
+
+if not HF_TOKEN:
+    st.error("⚠️ HF_TOKEN is not set. In your Space, add a Secret named HF_TOKEN.")
+else:
+    client = InferenceClient(model=GEN_MODEL, token=HF_TOKEN, timeout=60)
+
+TUTOR_PROMPT = (
+    "You are a kind Jamaican primary-school finance tutor. "
+    "Keep answers short, friendly, and age-appropriate. "
+    "Teach step-by-step with tiny examples. Avoid giving personal financial advice."
+)
+
+
+
+# -------------------------------
+# History helpers
+# -------------------------------
+def _format_history_for_flan(messages: list[dict]) -> str:
+    """Format history for text-generation style models."""
+    lines = []
+    for m in messages:
+        txt = (m.get("text") or "").strip()
+        if not txt:
+            continue
+        lines.append(("Tutor" if m.get("sender") == "assistant" else "User") + f": {txt}")
+    return "\n".join(lines)
+
+def _history_as_chat_messages(messages: list[dict]) -> list[dict]:
+    """Convert history to chat-completion style messages."""
+    msgs = [{"role": "system", "content": TUTOR_PROMPT}]
+    for m in messages:
+        txt = (m.get("text") or "").strip()
+        if not txt:
+            continue
+        role = "assistant" if m.get("sender") == "assistant" else "user"
+        msgs.append({"role": role, "content": txt})
+    return msgs
+
+def _extract_chat_text(chat_resp) -> str:
+    """Extract text from HF chat response."""
+    try:
+        return chat_resp.choices[0].message["content"] if isinstance(
+            chat_resp.choices[0].message, dict
+        ) else chat_resp.choices[0].message.content
+    except Exception:
+        try:
+            return chat_resp["choices"][0]["message"]["content"]
+        except Exception:
+            return str(chat_resp)
+
+# -------------------------------
+# Reply logic
+# -------------------------------
+def _reply_with_hf():
+    if "client" not in globals():
+        raise RuntimeError("HF client not initialized")
+
+    try:
+        # 1) Prefer chat API
+        msgs = _history_as_chat_messages(st.session_state.get("messages", []))
+        chat = client.chat.completions.create(
+            model=GEN_MODEL,
+            messages=msgs,
+            max_tokens=300,   # give enough room
+            temperature=0.2,
+            top_p=0.9,
+        )
+        return _extract_chat_text(chat).strip()
+
+    except ValueError as ve:
+        # 2) Fallback to text-generation if chat unsupported
+        if "Supported task: text-generation" in str(ve):
+            convo = _format_history_for_flan(st.session_state.get("messages", []))
+            tg_prompt = f"{TUTOR_PROMPT}\n\n{convo}\n\nTutor:"
+            resp = client.text_generation(
+                tg_prompt,
+                max_new_tokens=300,
+                temperature=0.2,
+                top_p=0.9,
+                repetition_penalty=1.1,
+                return_full_text=True,
+                stream=False,
+            )
+            return (resp.get("generated_text") if isinstance(resp, dict) else resp).strip()
+
+        raise  # rethrow anything else
+
+    except Exception as e:
+        err_text = ''.join(traceback.format_exception_only(type(e), e)).strip()
+        raise RuntimeError(f"Hugging Face API Error: {err_text}")
+
+# -------------------------------
+# Session message helper
+# -------------------------------
+def add_message(text: str, sender: str):
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+    st.session_state.messages.append(
+        {
+            "id": str(datetime.datetime.now().timestamp()),
+            "text": text,
+            "sender": sender,
+            "timestamp": datetime.datetime.now()
+        }
+    )
+
+def _coerce_ts(ts):
+    if isinstance(ts, datetime.datetime):
+        return ts
+    if isinstance(ts, (int, float)):
+        try:
+            return datetime.datetime.fromtimestamp(ts)
+        except Exception:
+            return None
+    if isinstance(ts, str):
+        # Try ISO 8601 first; fall back to float epoch
+        try:
+            return datetime.datetime.fromisoformat(ts)
+        except Exception:
+            try:
+                return datetime.datetime.fromtimestamp(float(ts))
+            except Exception:
+                return None
+    return None
+
+def _normalize_messages():
+    msgs = st.session_state.get("messages", [])
+    normed = []
+    now = datetime.datetime.now()
+    for m in msgs:
+        text = (m.get("text") or "").strip()
+        sender = m.get("sender") or "user"
+        ts = _coerce_ts(m.get("timestamp")) or now
+        normed.append({**m, "text": text, "sender": sender, "timestamp": ts})
+    st.session_state.messages = normed
+
+
+# -------------------------------
+# Streamlit page
+# -------------------------------
+def show_page():
+    st.title("🤖 AI Financial Tutor")
+    st.caption("Get personalized help with your financial questions")
+
+    if "messages" not in st.session_state:
+        st.session_state.messages = [{
+            "id": "1",
+            "text": "Hi! I'm your AI Financial Tutor. What would you like to learn today?",
+            "sender": "assistant",
+            "timestamp": datetime.datetime.now()
+        }]
+    if "is_typing" not in st.session_state:
+        st.session_state.is_typing = False
+
+    _normalize_messages()
+    
+    chat_container = st.container()
+    with chat_container:
+        for msg in st.session_state.messages:
+            time_str = msg["timestamp"].strftime("%H:%M") if hasattr(msg["timestamp"], "strftime") else datetime.datetime.now().strftime("%H:%M")
+            bubble = (
+                f"<div style='background-color:#e0e0e0; color:black; padding:10px; border-radius:12px; max-width:70%; margin-bottom:5px;'>"
+                f"{msg.get('text','')}<br><sub>{time_str}</sub></div>"
+                if msg.get("sender") == "assistant" else
+                f"<div style='background-color:#4CAF50; color:white; padding:10px; border-radius:12px; max-width:70%; margin-left:auto; margin-bottom:5px;'>"
+                f"{msg.get('text','')}<br><sub>{time_str}</sub></div>"
+            )
+            st.markdown(bubble, unsafe_allow_html=True)
+
+
+        if st.session_state.is_typing:
+            st.markdown("🤖 _FinanceBot is typing..._")
+
+    if len(st.session_state.messages) == 1:
+        st.markdown("Try asking about:")
+        cols = st.columns(2)
+        quick = [
+            "How does compound interest work?",
+            "How much should I save for emergencies?",
+            "What's a good budgeting strategy?",
+            "How do I start investing?"
+        ]
+        for i, q in enumerate(quick):
+            if cols[i % 2].button(q):
+                add_message(q, "user")
+                st.session_state.is_typing = True
+                st.rerun()
+
+    user_input = st.chat_input("Ask me anything about personal finance...")
+    if user_input:
+        add_message(user_input, "user")
+        st.session_state.is_typing = True
+        st.rerun()
+
+    if st.session_state.is_typing:
+        try:
+            with st.spinner("FinanceBot is thinking..."):
+                bot_reply = _reply_with_hf()
+                add_message(bot_reply, "assistant")
+        except Exception as e:
+            add_message(f"⚠️ Error: {e}", "assistant")
+        finally:
+            st.session_state.is_typing = False
+            st.rerun()
+
+    if st.button("Back to Dashboard", key="ai_tutor_back_btn"):
+        st.session_state.current_page = "Student Dashboard"
+        st.rerun()

phase/Student_view/game.py

@@ -0,0 +1,391 @@
+import streamlit as st
+from utils import db as dbapi
+import os
+import utils.api as api
+
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
+
+# --- Load external CSS (optional) ---
+def load_css(file_name: str):
+    try:
+        with open(file_name, "r", encoding="utf-8") as f:
+            st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+    except FileNotFoundError:
+        st.warning("⚠️ Stylesheet not found. Please ensure 'assets/styles.css' exists.")
+
+
+st.session_state.setdefault("current_game", None)
+
+
+# --- GAME RENDERERS ---
+def _render_budget_builder():
+    try:
+        from phase.Student_view.games import budgetbuilder as budget_module
+    except Exception as e:
+        st.error(f"Couldn't import Budget Builder module: {e}")
+        return
+
+    if hasattr(budget_module, "show_budget_builder"):
+        budget_module.show_budget_builder()
+    elif hasattr(budget_module, "show_page"):
+        budget_module.show_page()
+    else:
+        st.error("Budget Builder module found, but no show function (show_budget_builder/show_page).")
+
+def _render_debt_dilemma():
+    try:
+        from phase.Student_view.games import debtdilemma as debt_module
+    except Exception as e:
+        st.error(f"Couldn't import Debt Dilemma module: {e}")
+        return
+
+    if hasattr(debt_module, "show_debt_dilemma"):
+        debt_module.show_debt_dilemma()
+    elif hasattr(debt_module, "show_page"):
+        debt_module.show_page()
+    else:
+        st.error("Debt Dilemma module found, but no show function (show_debt_dilemma/show_page).")
+
+def _render_money_match():
+    """
+    Renders Money Match if the file exists at phase/games/MoneyMatch.py
+    and exposes a show_page() function.
+    """
+    try:
+        
+        from phase.Student_view.games  import MoneyMatch as mm_module
+    except Exception as e:
+        st.error(f"Couldn't import Money Match module: {e}")
+        st.info("Tip: ensure phase/games/MoneyMatch.py exists and defines show_page()")
+        return
+
+    if hasattr(mm_module, "show_page"):
+        mm_module.show_page()
+    else:
+        st.error("Money Match module found, but no show_page() function.")
+
+#render for profit puzzle 
+def _render_profit_puzzle():
+    try:
+        from phase.Student_view.games import profitpuzzle as pp_module
+    except Exception as e:
+        st.error(f"Couldn't import Profit Puzzle module: {e}")
+        return
+
+    if hasattr(pp_module, "show_profit_puzzle"):
+        pp_module.show_profit_puzzle()
+    elif hasattr(pp_module, "show_page"):
+        pp_module.show_page()
+    else:
+        st.error("Profit Puzzle module found, but no show function (show_profit_puzzle/show_page).")
+
+
+import textwrap
+
+def render_leaderboard(leaderboard):
+    def rank_symbol(rank):
+        if rank == "You":
+            return "🟢"
+        if isinstance(rank, int):
+            return "🥇" if rank == 1 else "🥈" if rank == 2 else "🥉" if rank == 3 else f"#{rank}"
+        return str(rank)
+
+    def rank_medal_class(rank):
+        if isinstance(rank, int) and rank in (1, 2, 3):
+            return f"medal-{rank}"
+        return ""
+
+    rows = []
+    head = '<div class="lb-head">🏆 Leaderboard</div>'
+    for p in leaderboard:
+        is_you = p["rank"] == "You"
+        medal_cls = rank_medal_class(p["rank"])
+        symbol = rank_symbol(p["rank"])
+        you_pill = '<span class="lb-you-pill">YOU</span>' if is_you else ""
+        rows.append(
+            textwrap.dedent(f"""
+            <div class="lb-row {'is-you' if is_you else ''}">
+              <div class="lb-rank {medal_cls}">{symbol}</div>
+              <div class="lb-name">{p['name']}</div>
+              <div class="lb-level">Lvl {p['level']}</div>
+              <div class="lb-xp">{p['xp']:,} XP</div>
+              {you_pill}
+            </div>
+            """).strip()
+        )
+
+    html = textwrap.dedent(f"""
+    <div class="leaderboard">
+      {head}
+      {''.join(rows)}
+    </div>
+    """).strip()
+
+    st.markdown(html, unsafe_allow_html=True)
+
+def _load_leaderboard(user_id: int, limit: int = 10) -> list[dict]:
+    you_name = (st.session_state.get("user") or {}).get("name") or "You"
+    class_id = st.session_state.get("current_class_id")
+    rows: list[dict] = []
+
+    try:
+        if USE_LOCAL_DB:
+            # ---------- local DB path ----------
+            if not class_id and hasattr(dbapi, "list_classes_for_student"):
+                classes = dbapi.list_classes_for_student(user_id) or []
+                if classes:
+                    class_id = classes[0]["class_id"]
+                    st.session_state.current_class_id = class_id
+
+            if class_id and hasattr(dbapi, "leaderboard_for_class"):
+                rows = dbapi.leaderboard_for_class(class_id, limit=limit) or []
+            elif hasattr(dbapi, "leaderboard_global"):
+                rows = dbapi.leaderboard_global(limit=limit) or []
+            elif class_id and hasattr(dbapi, "class_student_metrics"):
+                metrics = dbapi.class_student_metrics(class_id) or []
+                rows = [{
+                    "user_id": m.get("student_id"),
+                    "name": m.get("name") or m.get("email") or "Student",
+                    "xp": int(m.get("total_xp", 0)),
+                    "level": dbapi.level_from_xp(int(m.get("total_xp", 0))),
+                } for m in metrics]
+
+        else:
+            # ---------- backend API path (DISABLE_DB=1) ----------
+            # 1) pick a class for the logged-in student
+            if not class_id:
+                try:
+                    classes = api.list_classes_for_student(user_id) or []
+                except Exception:
+                    classes = []
+                if classes:
+                    class_id = classes[0].get("class_id")
+                    st.session_state.current_class_id = class_id
+
+            if class_id:
+                # 2) get roster
+                try:
+                    roster = api.list_students_in_class(class_id) or []
+                except Exception:
+                    roster = []
+
+                # 3) for each student, pull stats (XP/level)
+                rows = []
+                for s in roster:
+                    sid = s.get("user_id") or s.get("student_id")
+                    if not sid:
+                        continue
+                    try:
+                        stt = api.user_stats(int(sid)) or {}
+                    except Exception:
+                        stt = {}
+                    rows.append({
+                        "user_id": int(sid),
+                        "name": s.get("name") or s.get("email") or "Student",
+                        "xp": int(stt.get("xp", 0)),
+                        "level": int(stt.get("level", 1)),
+                    })
+            else:
+                # No class available; at least show the current user
+                try:
+                    s = api.user_stats(user_id) or {}
+                except Exception:
+                    s = {}
+                rows = [{"user_id": user_id, "name": you_name,
+                         "xp": int(s.get("xp", 0)), "level": int(s.get("level", 1))}]
+    except Exception:
+        rows = []
+
+    # Ensure YOU is present
+    if not any(r.get("user_id") == user_id for r in rows):
+        rows.append({"user_id": user_id, "name": you_name, "xp": 0, "level": 1})
+
+    # Rank, mark YOU, put YOU first
+    rows.sort(key=lambda r: int(r.get("xp", 0)), reverse=True)
+    ranked = []
+    for i, r in enumerate(rows, start=1):
+        ranked.append({
+            "rank": i,
+            "user_id": r["user_id"],
+            "name": r["name"],
+            "level": int(r["level"]),
+            "xp": int(r["xp"]),
+        })
+    for r in ranked:
+        if r["user_id"] == user_id:
+            r["rank"] = "You"
+            break
+    you = [r for r in ranked if r["rank"] == "You"]
+    others = [r for r in ranked if r["rank"] != "You"]
+    return (you + others)[:limit]
+
+
+
+
+# --- MAIN GAMES HUB & ROUTER ---
+def show_games():
+    load_css(os.path.join("assets", "styles.css"))
+    
+    if "user" not in st.session_state or st.session_state.user is None:
+        st.error("❌ Please login first.")
+        st.session_state.current_page = "Welcome"
+        st.rerun()
+
+    game_key = st.session_state.current_game
+
+    # If a specific game is active → render it
+    if game_key is not None:
+        if game_key == "budget_builder":
+            _render_budget_builder()
+        elif game_key == "money_match":
+            _render_money_match()
+        elif game_key == "debt_dilemma":
+             _render_debt_dilemma()
+        elif game_key == "profit_puzzle":
+            _render_profit_puzzle()
+
+        st.markdown("---")
+        if st.button("⬅ Back to Games Hub"):
+            st.session_state.current_game = None
+            st.rerun()
+        return  # don’t render the hub
+
+    # ===== Games Hub =====
+    st.title("Financial Games")
+    st.subheader("Learn by playing! Master financial concepts through interactive games.")
+
+     # Progress overview
+    col1, col2 = st.columns([1, 5])
+    with col1:
+        st.markdown(
+            """
+            <div style="
+                width:50px; height:50px;
+                border-radius:15px;
+                background: linear-gradient(135deg, #22c55e, #059669);
+                display:flex; align-items:center; justify-content:center;
+                font-size:28px;
+                box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+            ">
+                ✨
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
+
+    with col2:
+        # pull live XP/level
+        user_id = st.session_state.user["user_id"]
+
+        # Prefer local DB only if enabled. Otherwise call backend.
+        if USE_LOCAL_DB and hasattr(dbapi, "user_xp_and_level"):
+            stats = dbapi.user_xp_and_level(user_id)   # {'xp', 'level', 'streak', maybe 'into','need'}
+        else:
+            try:
+                stats = api.user_stats(user_id)        # backend /students/{id}/stats
+            except Exception as e:
+                # hard fallback so the page still renders
+                stats = {"xp": int(st.session_state.get("xp", 0)), "level": 1, "streak": 0}
+
+        total_xp = int(stats.get("xp", 0))
+        level    = int(stats.get("level", 1))
+        st.session_state.xp     = total_xp
+        st.session_state.streak = int(stats.get("streak", 0))
+
+        # Show progress as TOTAL XP toward the NEXT threshold
+        base = 500
+        # keep the server's level if it is sane, otherwise recompute
+        level = level if level >= 1 else max(1, total_xp // base + 1)
+
+        cap = level * base                 # Level 1 -> 500, Level 2 -> 1000, etc.
+        progress_pct = min(100, int(round((total_xp / cap) * 100)))
+
+        st.write(f"Level {level} Experience Points")
+        st.markdown(f"""
+            <div style="background:#e0e0e0;border-radius:12px;padding:3px;width:100%;">
+                <div style="
+                    width:{progress_pct}%;
+                    background:linear-gradient(135deg,#22c55e,#059669);
+                    height:24px;border-radius:10px;text-align:right;
+                    color:white;font-weight:bold;padding-right:8px;line-height:24px;">
+                    {total_xp:,} / {cap:,} XP
+                </div>
+            </div>
+            <div style="font-size:12px;color:#6b7280;margin-top:6px;">Total XP: {total_xp:,}</div>
+        """, unsafe_allow_html=True)
+
+    st.markdown("---")
+
+        # Game list
+    games = [
+        {"key": "money_match", "icon": "💰", "title": "Money Match",
+         "description": "Drag coins and notes to match target values. Perfect for learning denominations!",
+         "difficulty": "Easy", "xp": "+10 XP", "time": "5-10 min", "color": "linear-gradient(135deg, #22c55e, #059669)"},
+        {"key": "budget_builder", "icon": "📊", "title": "Budget Builder",
+         "description": "Allocate your weekly allowance across different spending categories with real-time pie charts.",
+         "difficulty": "Easy", "xp": "+50 XP", "time": "10-15 min", "color": "linear-gradient(135deg, #3b82f6, #06b6d4)"},
+         {"key": "profit_puzzle", "icon": "🧩", "title": "Profit Puzzle",
+         "description": "Solve business scenarios with interactive sliders. Calculate profit, revenue, and costs!",
+         "difficulty": "Medium", "xp": "+150 XP", "time": "10-15 min", "color": "linear-gradient(135deg, #6366f1, #8b5cf6)"},
+        {"key": "debt_dilemma", "icon": "⚠️", "title": "Debt Dilemma",
+         "description": "Experience borrowing JA$100 and learn about interest, repayment schedules, and credit scores.",
+         "difficulty": "Hard", "xp": "+200 XP", "time": "20-25 min", "color": "linear-gradient(135deg, #f97316, #dc2626)"},
+        ]
+
+    cols = st.columns(2)
+    color_map = {"Easy": "green", "Medium": "orange", "Hard": "red"}
+
+    for i, g in enumerate(games):
+        with cols[i % 2]:
+            st.markdown(
+                f"""
+                <div style="
+                    width:60px; height:60px;
+                    border-radius:16px;
+                    background:{g['color']};
+                    display:flex; align-items:center; justify-content:center;
+                    font-size:28px; margin-bottom:10px;
+                    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+                ">
+                    {g['icon']}
+                </div>
+                """,
+                unsafe_allow_html=True
+            )
+            st.subheader(g["title"])
+            st.write(g["description"])
+            diff_color = color_map.get(g["difficulty"], "gray")
+            st.markdown(
+                f"<div style='color:{diff_color}; font-weight:bold'>{g['difficulty']}</div> | "
+                f"{g['xp']} | {g['time']}",
+                unsafe_allow_html=True
+            )
+            if st.button("▶ Play Now", key=f"play_{g['key']}"):
+                st.session_state.current_game = g["key"]
+                st.rerun()
+
+
+    st.markdown("---")
+    
+    # Leaderboard & Tips
+    col_leader, col_tips = st.columns(2)
+    with col_leader:
+        user_id = st.session_state.user["user_id"]
+        lb = _load_leaderboard(user_id, limit=10)
+        if lb:
+            render_leaderboard(lb)
+        else:
+            st.info("No leaderboard data yet.")
+
+
+       
+
+    with col_tips:
+        st.subheader("Game Tips")
+        for tip in [
+            "🌟 Start with easier games to build confidence",
+            "⏰ Take your time to understand concepts",
+            "🏆 Replay games to improve your score",
+            "🌍 Apply game lessons to real life",
+        ]:
+            st.markdown(f"- {tip}")

phase/Student_view/games/MoneyMatch.py

@@ -0,0 +1,208 @@
+# phase\Student_view\games\MoneyMatch.py
+
+import time
+import os
+import random
+from pathlib import Path
+import streamlit as st
+from utils import db as dbapi
+import time
+from utils import db as db_util
+from utils import api   
+
+
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
+
+
+# ---------- paths ----------
+PROJECT_ROOT = Path(__file__).resolve().parents[3]
+
+def _asset(*parts: str) -> str:
+    # JMD image path
+    return str((PROJECT_ROOT / "assets" / "images" / Path(*parts)).resolve())
+
+def _safe_image(path: str, *, caption: str = ""):
+    if not os.path.exists(path):
+        st.warning(f"Image not found: {Path(path).name}. Button still works.")
+        return False
+    st.image(path, use_container_width=True, caption=caption)
+    return True
+
+# ---------- state helpers ----------
+def _init_state():
+    ss = st.session_state
+    if "mm_level" not in ss: ss.mm_level = 1
+    if "mm_xp" not in ss: ss.mm_xp = 0
+    if "mm_matches" not in ss: ss.mm_matches = 0
+    if "mm_target" not in ss: ss.mm_target = random.randint(7, 10000)  # randon goal generator
+    if "mm_selected" not in ss: ss.mm_selected = []
+    if "mm_total" not in ss: ss.mm_total = 0
+    if "mm_start_ts" not in ss: ss.mm_start_ts = time.perf_counter()
+    if "mm_saved" not in ss: ss.mm_saved = False
+
+def _reset_round(new_target: int | None = None):
+    ss = st.session_state
+    ss.mm_selected = []
+    ss.mm_total = 0
+    ss.mm_target = new_target if new_target is not None else random.randint(7, 10000)
+    ss.mm_start_ts = time.perf_counter()
+    ss.mm_saved = False
+
+def _award_xp(gained: int):
+    ss = st.session_state
+    ss.mm_xp += gained
+    ss.mm_matches += 1
+    while ss.mm_xp >= ss.mm_level * 100:
+        ss.mm_level += 1
+
+def _persist_success(gained_xp: int):
+    user = st.session_state.get("user") or {}
+    user_id = int(user.get("user_id", 0))
+    if not user_id:
+        st.error("Not saving. No logged-in user_id in session.")
+        return
+
+    payload = dict(
+        user_id=user_id,
+        target=int(st.session_state.mm_target),
+        total=int(st.session_state.mm_total),
+        elapsed_ms=int((time.perf_counter() - st.session_state.mm_start_ts) * 1000),
+        matched=True,
+        gained_xp=int(gained_xp),
+    )
+
+    try:
+        if USE_LOCAL_DB and hasattr(dbapi, "record_money_match_play"):
+            # direct DB mode
+            dbapi.record_money_match_play(**payload)
+            st.toast(f"Saved to DB  +{gained_xp} XP")
+        else:
+            # backend mode (DISABLE_DB=1)
+            api.record_money_match_play(**payload)
+            st.toast(f"Saved via backend  +{gained_xp} XP")
+        st.session_state.mm_saved = True
+    except Exception as e:
+        st.error(f"Save failed: {e}")
+
+
+# --- CSS injection (run every render) ---
+def _inject_css():
+    css_path = PROJECT_ROOT / "assets" / "styles.css"
+    try:
+        css = css_path.read_text(encoding="utf-8")
+        st.markdown(f"<style>{css}</style>", unsafe_allow_html=True)
+    except Exception:
+        # don't crash the page because of styling
+        pass
+
+
+# ---------- denominations ----------
+DENOMS = [
+    ("JA$1",     1,    _asset("jmd", "jmd_1.jpeg")),
+    ("JA$5",     5,    _asset("jmd", "jmd_5.jpeg")),
+    ("JA$10",    10,   _asset("jmd", "jmd_10.jpeg")),
+    ("JA$20",    20,   _asset("jmd", "jmd_20.jpeg")),
+    ("JA$50",    50,   _asset("jmd", "jmd_50.jpg")),
+    ("JA$100",   100,  _asset("jmd", "jmd_100.jpg")),
+    ("JA$500",   500,  _asset("jmd", "jmd_500.jpg")),
+    ("JA$1000",  1000, _asset("jmd", "jmd_1000.jpeg")),
+    ("JA$2000",  2000, _asset("jmd", "jmd_2000.jpeg")),
+    ("JA$5000",  5000, _asset("jmd", "jmd_5000.jpeg")),
+]
+
+# ---------- main ----------
+def show_page():
+    _init_state()
+    _inject_css()   # <- keep this here so it runs on every rerun
+    ss = st.session_state
+
+
+    if st.button("← Back to Games"):
+        ss.current_game = None
+        st.rerun()
+
+    st.title("Money Match Challenge")
+
+    left, right = st.columns([1.75, 1])
+
+    with left:
+        st.markdown('<div class="mm-card">', unsafe_allow_html=True)
+        st.markdown(f"<h3>Target: <span class='mm-target'>JA${ss.mm_target}</span></h3>", unsafe_allow_html=True)
+        st.markdown(f"<div class='mm-total'>JA${ss.mm_total}</div>", unsafe_allow_html=True)
+
+        ratio = min(ss.mm_total / ss.mm_target, 1.0) if ss.mm_target else 0
+        st.progress(ratio)
+
+        diff = ss.mm_target - ss.mm_total
+        need_text = "Perfect match. Click Next round." if diff == 0 else (f"Need JA${diff} more" if diff > 0 else f"Overshot by JA${abs(diff)}")
+        st.caption(need_text)
+
+        # autosave stats if perfect match
+        if diff == 0 and not ss.mm_saved:
+             gained = 10
+             _persist_success(gained)
+             _award_xp(gained)
+             ss.mm_saved = True
+
+        # tray
+        if ss.mm_selected:
+            chips = " ".join([f"<span class='mm-chip'>${v}</span>" for v in ss.mm_selected])
+            st.markdown(f"<div class='mm-tray'>{chips}</div>", unsafe_allow_html=True)
+        else:
+            st.markdown("<div class='mm-tray mm-empty'>Selected money will appear here</div>", unsafe_allow_html=True)
+
+        c1, c2 = st.columns([1,1])
+        with c1:
+            if st.button("⟲ Reset"):
+                _reset_round(ss.mm_target)
+                st.rerun()
+        with c2:
+            if ss.mm_total == ss.mm_target:
+                if st.button("Next round ▶"):
+                    gained = 10
+                    # avoid double insert when autosave
+                    if not ss.mm_saved:
+                        _persist_success(gained)
+                        _award_xp(gained)
+                    _reset_round()
+                    st.rerun()
+
+        st.markdown("</div>", unsafe_allow_html=True)
+
+        # Money Collection
+        st.markdown("<h4>Money Collection</h4>", unsafe_allow_html=True)
+        grid_cols = st.columns(4)
+        for i, (label, value, img) in enumerate(DENOMS):
+            with grid_cols[i % 4]:
+                _safe_image(img, caption=label)
+                if st.button(label, key=f"mm_add_{value}"):
+                    ss.mm_selected.append(value)
+                    ss.mm_total += value
+                    st.rerun()
+
+    with right:
+        st.markdown(
+            f"""
+            <div class="mm-side-card">
+                <h4>🏆 Stats</h4>
+                <div class="mm-metric"><span>Current Level</span><b>{ss.mm_level}</b></div>
+                <div class="mm-metric"><span>Total XP</span><b>{ss.mm_xp}</b></div>
+                <div class="mm-metric"><span>Matches Made</span><b>{ss.mm_matches}</b></div>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+        st.markdown(
+            """
+            <div class="mm-side-card">
+                <h4>How to Play</h4>
+                <ol class="mm-howto">
+                    <li>Look at the target amount</li>
+                    <li>Click coins and notes to add them</li>
+                    <li>Match the target exactly to earn XP</li>
+                    <li>Level up with each successful match</li>
+                </ol>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )

phase/Student_view/games/budgetbuilder.py

@@ -0,0 +1,565 @@
+# phase\Student_view\games\budgetbuilder.py
+
+import streamlit as st
+import os, time
+from utils import api as backend
+from utils import db as dbapi
+
+DISABLE_DB = os.getenv("DISABLE_DB", "1") == "1"
+
+def _rerun():
+    try:
+        st.rerun()
+    except AttributeError:
+        st.experimental_rerun()
+
+
+def _refresh_global_xp():
+    user = st.session_state.get("user")
+    if not user:
+        return
+    try:
+        stats = backend.user_stats(user["user_id"]) if DISABLE_DB else dbapi.user_xp_and_level(user["user_id"])
+        st.session_state.xp = stats.get("xp", st.session_state.get("xp", 0))
+        st.session_state.streak = stats.get("streak", st.session_state.get("streak", 0))
+    except Exception as e:
+        st.warning(f"XP refresh failed: {e}")
+
+
+def _persist_budget_result(level_cfg: dict, success: bool, gained_xp: int):
+    user = st.session_state.get("user")
+    if not user:
+        st.info("Login to earn and save XP.")
+        return
+
+    try:
+        elapsed_ms = int((time.time() - st.session_state.get("bb_start_ts", time.time())) * 1000)
+        allocations = [{"id": cid, "amount": int(val)} for cid, val in st.session_state.categories.items()]
+        budget_score = 100 if success else 0
+
+        if DISABLE_DB:
+            backend.record_budget_builder_play(
+                user_id=user["user_id"],
+                weekly_allowance=int(level_cfg["income"]),
+                budget_score=int(budget_score),
+                elapsed_ms=elapsed_ms,
+                allocations=allocations,
+                gained_xp=int(gained_xp),
+            )
+        else:
+            # Local DB path (if your db layer has one of these)
+            if hasattr(dbapi, "record_budget_builder_result"):
+                dbapi.record_budget_builder_result(
+                    user_id=user["user_id"],
+                    weekly_allowance=int(level_cfg["income"]),
+                    budget_score=int(budget_score),
+                    elapsed_ms=elapsed_ms,
+                    allocations=allocations,
+                    gained_xp=int(gained_xp),
+                )
+            elif hasattr(dbapi, "award_xp"):
+                dbapi.award_xp(user["user_id"], int(gained_xp), reason="budget_builder")
+
+        _refresh_global_xp()  # <-- this makes the XP bar move immediately
+    except Exception as e:
+        st.warning(f"Could not save budget result: {e}")
+
+
+def show_budget_builder():
+
+    # timer for elapsed_ms
+    if "bb_start_ts" not in st.session_state:
+        st.session_state.bb_start_ts = time.time()
+
+
+    # Add custom CSS for improved styling
+    st.markdown("""
+    <style>
+    /* Main container styling */
+    .main .block-container {
+        padding-top: 2rem;
+        padding-bottom: 2rem;
+        max-width: 1200px;
+    }
+    
+    /* Card-like styling for sections */
+    .budget-card {
+        background: white;
+        border-radius: 12px;
+        padding: 1.5rem;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+        margin-bottom: 1.5rem;
+        border: 1px solid #e5e7eb;
+    }
+    
+    /* Header styling */
+    .main h1 {
+        color: #1f2937;
+        font-weight: 700;
+        margin-bottom: 0.5rem;
+    }
+    
+    .main h2 {
+        color: #374151;
+        font-weight: 600;
+        margin-bottom: 1rem;
+        font-size: 1.5rem;
+    }
+    
+    .main h3 {
+        color: #4b5563;
+        font-weight: 600;
+        margin-bottom: 0.75rem;
+        font-size: 1.25rem;
+    }
+    
+    /* Slider styling improvements */
+    .stSlider > div > div > div > div {
+        background-color: #f3f4f6;
+        border-radius: 8px;
+    }
+    
+    /* Updated button styling with specific colors for Check Budget (green) and Reset (gray) */
+    .stButton > button {
+        border-radius: 8px;
+        border: none;
+        font-weight: 600;
+        padding: 0.5rem 1rem;
+        transition: all 0.2s;
+    }
+    
+    .stButton > button:hover {
+        transform: translateY(-1px);
+        box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+    }
+    
+    /* Green button for Check Budget */
+    .stButton > button[kind="primary"] {
+        background-color: #10b981;
+        color: white;
+    }
+    
+    .stButton > button[kind="primary"]:hover {
+        background-color: #059669;
+    }
+    
+    /* Gray button for Reset */
+    .stButton > button[kind="secondary"] {
+        background-color: white;
+        color: black;
+    }
+    
+    .stButton > button[kind="secondary"]:hover {
+        background-color: #f3f4f6;
+    }
+    
+    /* Success/Error message styling */
+    .stSuccess {
+        border-radius: 8px;
+        border-left: 4px solid #10b981;
+    }
+    
+    .stError {
+        border-radius: 8px;
+        border-left: 4px solid #ef4444;
+    }
+    
+    /* Metric styling */
+    .metric-container {
+        background: linear-gradient(135deg, #f8fafc 0%, #f1f5f9 100%);
+        border-radius: 12px;
+        padding: 1rem;
+        border: 1px solid #e2e8f0;
+        text-align: center;
+        margin-bottom: 1rem;
+    }
+    
+    /* Table styling */
+    .stTable {
+        border-radius: 8px;
+        overflow: hidden;
+        border: 1px solid #e5e7eb;
+    }
+    
+    /* Progress bar styling */
+    .stProgress > div > div > div {
+        background-color: #10b981;
+        border-radius: 4px;
+    }
+    
+    /* Info box styling */
+    .stInfo {
+        border-radius: 8px;
+        border-left: 4px solid #3b82f6;
+        background-color: #eff6ff;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+    # -----------------------------
+    # Define Levels and Categories
+    # -----------------------------
+    levels = [
+        {
+            "id": 1,
+            "title": "First Budget",
+            "description": "Learn basic budget allocation",
+            "scenario": "You're 14 and just started getting a weekly allowance. Your parents want to see you can manage money responsibly before increasing it.",
+            "income": 300,
+            "objectives": [
+                "Save at least 20% of your income",
+                "Don't spend more than 30% on entertainment",
+                "Allocate money for food and transport"
+            ],
+            "constraints": {
+                "savings": {"min": 60},
+                "fun": {"max": 90},
+                "food": {"min": 40, "required": True},
+                "transport": {"min": 30, "required": True},
+            },
+            "success": [
+                ("Save at least JA$60 (20%)", lambda cats, inc: cats["savings"] >= 60),
+                ("Keep entertainment under JA$90 (30%)", lambda cats, inc: cats["fun"] <= 90),
+                ("Balance your budget completely", lambda cats, inc: sum(cats.values()) == inc),
+            ],
+            "xp": 20,
+        },
+        {
+            "id": 2,
+            "title": "Emergency Fund",
+            "description": "Build an emergency fund while managing expenses",
+            "scenario": "Your phone broke last month and you had no savings to fix it. This time, build an emergency fund while still enjoying life.",
+            "income": 400,
+            "objectives": [
+                "Build an emergency fund (JA$100+)",
+                "Still save for long-term goals",
+                "Cover all essential expenses",
+            ],
+            "constraints": {
+                "savings": {"min": 150},  # Emergency + regular savings
+                "food": {"min": 60, "required": True},
+                "transport": {"min": 40, "required": True},
+                "school": {"min": 20, "required": True},
+            },
+            "success": [
+                ("Save at least JA$150 total", lambda cats, inc: cats["savings"] >= 150),
+                (
+                    "Cover all essential expenses",
+                    lambda cats, inc: cats["food"] >= 60
+                    and cats["transport"] >= 40
+                    and cats["school"] >= 20,
+                ),
+            ],
+            "xp": 30,
+        },
+        {
+            "id": 3,
+            "title": "Reduced Income",
+            "description": "Manage when money is tight",
+            "scenario": "Your allowance got cut because of family finances. You need to make tough choices while still maintaining your savings habit.",
+            "income": 250,
+            "objectives": [
+                "Still save something (minimum JA$25)",
+                "Cut non-essential spending",
+                "Maintain essential expenses",
+            ],
+            "constraints": {
+                "savings": {"min": 25},
+                "fun": {"max": 40},
+                "food": {"min": 50, "required": True},
+                "transport": {"min": 35, "required": True},
+            },
+            "success": [
+                ("Save at least JA$25 (10%)", lambda cats, inc: cats["savings"] >= 25),
+                ("Keep entertainment under JA$40", lambda cats, inc: cats["fun"] <= 40),
+                ("Balance your budget", lambda cats, inc: sum(cats.values()) == inc),
+            ],
+            "xp": 35,
+        },
+        {
+            "id": 4,
+            "title": "Debt & Goals",
+            "description": "Pay off debt while saving for something special",
+            "scenario": "You borrowed JA$100 from your parents for a school trip. Now you need to pay it back (JA$25/week) while saving for a new game console.",
+            "income": 450,
+            "objectives": [
+                "Pay debt installment (JA$25)",
+                "Save for console (JA$50+ per week)",
+                "Don't compromise on essentials",
+            ],
+            "constraints": {
+                "savings": {"min": 75},  # 50 for console + 25 debt payment
+                "food": {"min": 70, "required": True},
+                "transport": {"min": 45, "required": True},
+                "school": {"min": 30, "required": True},
+            },
+            "success": [
+                ("Allocate JA$75+ for savings & debt", lambda cats, inc: cats["savings"] >= 75),
+                (
+                    "Cover all essentials adequately",
+                    lambda cats, inc: cats["food"] >= 70
+                    and cats["transport"] >= 45
+                    and cats["school"] >= 30,
+                ),
+            ],
+            "xp": 40,
+        },
+        {
+            "id": 5,
+            "title": "Master Budgeter",
+            "description": "Handle multiple financial goals like an adult",
+            "scenario": "You're 16 now with part-time job income. Manage multiple goals: emergency fund, college savings, social life, and family contribution.",
+            "income": 600,
+            "objectives": [
+                "Build emergency fund (JA$50)",
+                "Save for college (JA$100)",
+                "Contribute to family (JA$40)",
+                "Maintain social life and hobbies",
+            ],
+            "constraints": {
+                "savings": {"min": 150},  # Emergency + college
+                "charity": {"min": 40},   # Family contribution
+                "food": {"min": 80, "required": True},
+                "transport": {"min": 60, "required": True},
+                "school": {"min": 50, "required": True},
+            },
+            "success": [
+                ("Save JA$150+ for future goals", lambda cats, inc: cats["savings"] >= 150),
+                ("Contribute JA$40+ to family", lambda cats, inc: cats["charity"] >= 40),
+                (
+                    "Balance entertainment & responsibilities",
+                    lambda cats, inc: cats["fun"] >= 30 and cats["fun"] <= 150,
+                ),
+                ("Perfect budget balance", lambda cats, inc: sum(cats.values()) == inc),
+            ],
+            "xp": 50,
+        },
+    ]
+
+    # -----------------------------
+    # Initialize Session State
+    # -----------------------------
+    if "current_level" not in st.session_state:
+        st.session_state.current_level = 1
+    if "completed_levels" not in st.session_state:
+        st.session_state.completed_levels = []
+    if "categories" not in st.session_state:
+        st.session_state.categories = {}
+    if "level_completed" not in st.session_state:
+        st.session_state.level_completed = False
+
+    # -----------------------------
+    # Categories Master
+    # -----------------------------
+    categories_master = {
+        "food": {"name": "Food & Snacks", "color": "#16a34a", "icon": "🍎", "min": 0, "max": 300},
+        "savings": {"name": "Savings", "color": "#2563eb", "icon": "💰", "min": 0, "max": 400},
+        "fun": {"name": "Entertainment", "color": "#dc2626", "icon": "🎮", "min": 0, "max": 300},
+        "charity": {"name": "Charity/Family", "color": "#e11d48", "icon": "❤️", "min": 0, "max": 200},
+        "transport": {"name": "Transport", "color": "#ea580c", "icon": "🚌", "min": 0, "max": 200},
+        "school": {"name": "School Supplies", "color": "#0891b2", "icon": "📚", "min": 0, "max": 150},
+    }
+    if not st.session_state.categories:
+        st.session_state.categories = {cid: 0 for cid in categories_master.keys()}
+
+    # -----------------------------
+    # Current Level Setup
+    # -----------------------------
+    level = [l for l in levels if l["id"] == st.session_state.current_level][0]
+
+    # Header section with improved styling
+    st.markdown(f"""
+    <div style="text-align: center; padding: 2rem 0; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
+                border-radius: 12px; margin-bottom: 2rem; color: white;">
+        <h1 style="color: white; margin-bottom: 0.5rem;">💵 Budget Builder</h1>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Level progress indicator
+    st.markdown(f"""
+    <div style="background: #f8fafc; border-radius: 8px; padding: 1rem; margin-bottom: 2rem; border: 1px solid #e2e8f0;">
+        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 0.5rem;">
+            <span style="font-weight: 600; color: #374151;">Level Progress</span>
+            <span style="color: #6b7280;">{len(st.session_state.completed_levels)}/5 Complete</span>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Scenario description with better styling
+    st.markdown(f"""
+    <div style="background: #eff6ff; border-radius: 8px; padding: 1.5rem; margin-bottom: 2rem; 
+                border-left: 4px solid #3b82f6;">
+        <h4 style="color: #1e40af; margin-bottom: 0.5rem;">📖 Scenario</h4>
+        <p style="color: #1f2937; margin-bottom: 1rem;">{level["scenario"]}</p>
+        <div style="background: white; border-radius: 6px; padding: 1rem; border: 1px solid #dbeafe;">
+            <strong style="color: #059669;">Weekly Income: JA${level['income']}</strong>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # -----------------------------
+    # Two-column layout
+    # -----------------------------
+    left_col, right_col = st.columns([2, 1], gap="large")
+
+    with left_col:
+        st.markdown(f"""
+        <div class="budget-card" style="background: #f8fafc; border-left: 4px solid #10b981;">
+            <h3 style="color: #059669; margin-bottom: 1rem;">🎯 Objectives</h3>
+            {''.join([f'<div style="margin-bottom: 0.5rem; color: #374151;">• {obj}</div>' for obj in level["objectives"]])}
+        </div>
+        """, unsafe_allow_html=True)
+
+        st.markdown("""
+        <h2 style="color: #374151; margin-bottom: 1.5rem;">💰 Budget Allocation</h3>
+        <p style="color: #6b7280; margin-bottom: 1.5rem;">Use the sliders below to allocate your weekly income across different categories. Make sure to meet the objectives!</p>
+        """, unsafe_allow_html=True)
+
+        st.markdown("### 📊 Allocate Your Budget")
+        # Render sliders without dynamic inter-dependencies
+        for cid, cat in categories_master.items():
+            constraints = level["constraints"].get(cid, {})
+            min_val = 0
+            #max is set to the level income for more flexibility
+            max_val = level["income"]
+            st.session_state.categories[cid] = st.slider(
+                f"{cat['icon']} {cat['name']}",
+                min_value=min_val,
+                max_value=max_val,
+                value=st.session_state.categories[cid],
+                step=5,
+                help=f"Min: JA${min_val}, Max: JA${max_val}"
+            )
+
+        # Calculate totals after sliders have been selected
+        total_allocated = sum(st.session_state.categories.values())
+        remaining = level["income"] - total_allocated
+        st.metric("Remaining", f"JA${remaining}", delta_color="inverse" if remaining < 0 else "normal")
+
+        
+        # Remaining budget display with better styling
+        color = "#ef4444" if remaining < 0 else "#059669" if remaining == 0 else "#f59e0b"
+        st.markdown(f"""
+        <div class="metric-container" style="border-left: 4px solid {color};">
+            <h4 style="color: #6b7280; margin-bottom: 0.5rem;">Remaining Budget</h4>
+            <h2 style="color: {color}; margin: 0;">JA${remaining}</h2>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("✅ Check Budget", use_container_width=True, type="primary"):
+                results = [(desc, fn(st.session_state.categories, level["income"])) for desc, fn in level["success"]]
+                all_passed = all(r[1] for r in results)
+
+                if all_passed and remaining == 0:
+                    st.success(f"🎉 Level {level['id']} Complete! +{level['xp']} XP")
+                    st.session_state.level_completed = True
+                    if level["id"] not in st.session_state.completed_levels:
+                        st.session_state.completed_levels.append(level["id"])
+
+                    # award exactly once per level
+                    award_key = f"_bb_xp_awarded_L{level['id']}"
+                    if not st.session_state.get(award_key):
+                        _persist_budget_result(level, success=True, gained_xp=int(level["xp"]))
+                        st.session_state[award_key] = True
+                else:
+                    st.error("❌ Not complete yet. Check the requirements!")
+                    for desc, passed in results:
+                        icon = "✅" if passed else "⚠️"
+                        st.markdown(f"{icon} {desc}")
+
+        with col2:
+            # Reset button
+            if st.button("🔄 Reset Budget", use_container_width=True, type="secondary"):
+                # Reset all category amounts
+                for cid in categories_master.keys():
+                    st.session_state[cid] = 0
+                # Reset the dictionary in session_state too
+                st.session_state.categories = {cid: 0 for cid in categories_master.keys()}
+                st.session_state.level_completed = False
+                st.rerun()
+
+
+        # Next Level button
+        if st.session_state.level_completed and st.session_state.current_level < len(levels):
+            if st.button("➡️ Next Level", use_container_width=True, type="primary"):
+                st.session_state.current_level += 1
+                st.session_state.categories = {cid: 0 for cid in categories_master.keys()}
+                st.session_state.level_completed = False
+                st.session_state.bb_start_ts = time.time()  # <-- reset timer
+                st.rerun()
+
+
+    with right_col:
+        criteria_html = ""
+        for desc, fn in level["success"]:
+            passed = fn(st.session_state.categories, level["income"])
+            icon = "✅" if passed else "⚠️"
+            color = "#059669" if passed else "#f59e0b"
+            criteria_html += f"<div style='margin-bottom: 0.5rem; color: {color};'>{icon} {desc}</div>"
+        
+        st.markdown(f"""
+        <div class="budget-card">
+            <h3 style="color: #374151; margin-bottom: 1rem;">✅ Success Criteria</h3>
+            {criteria_html}
+        </div>
+        """, unsafe_allow_html=True)
+
+        breakdown_html = ""
+        for cid, amount in st.session_state.categories.items():
+            if amount > 0:
+                cat = categories_master[cid]
+                percentage = (amount / level["income"]) * 100
+                breakdown_html += f"""
+        <div style="display:flex; justify-content:space-between; align-items:center; 
+                    padding:0.5rem; margin-bottom:0.5rem; background:#f8fafc; border-radius:6px;">
+            <span style="color:#374151;">{cat['icon']} {cat['name']}</span>
+            <div style="text-align:right;">
+                <div style="font-weight:600; color:#1f2937;">JA${amount}</div>
+                <div style="font-size:0.8rem; color:#6b7280;">{percentage:.1f}%</div>
+            </div>
+        </div>
+        """
+
+        st.markdown(f"""
+        <div class="budget-card">
+            <h3 style="color:#374151; margin-bottom:1rem;">📊 Budget Breakdown</h3>
+            {breakdown_html}
+        </div>
+        """, unsafe_allow_html=True)
+
+
+        st.markdown("""
+        <div class="budget-card" style="background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%); 
+                    border-left: 4px solid #f59e0b;">
+            <h3 style="color: #92400e; margin-bottom: 1rem;">💡 Level Tips</h3>
+            <div style="color: #451a03;">
+                <div style="margin-bottom: 0.5rem;">💰 Start with essentials like food and transport</div>
+                <div style="margin-bottom: 0.5rem;">🎯 The 50/30/20 rule: needs, wants, savings</div>
+                <div>📊 Review and adjust your budget regularly</div>
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+        
+    if len(st.session_state.completed_levels) == len(levels):
+        st.balloons()
+        st.markdown("""
+        <div style="text-align: center; padding: 2rem; background: linear-gradient(135deg, #10b981 0%, #059669 100%); 
+                    border-radius: 12px; color: white; margin-top: 2rem;">
+            <h2 style="color: white; margin-bottom: 1rem;">🎉 Congratulations!</h2>
+            <h3 style="color: #d1fae5; margin: 0;">You are now a Master Budgeter!</h3>
+        </div>
+        <br>
+        """, unsafe_allow_html=True)
+
+        # Show a restart button
+        if st.button("🔄 Restart Game"):
+            st.session_state.current_level = 1
+            st.session_state.completed_levels = []
+            st.session_state.categories = {cid: 0 for cid in categories_master.keys()}
+            st.session_state.level_completed = False
+            st.session_state.bb_start_ts = time.time()  # <-- reset timer
+            st.rerun()

phase/Student_view/games/debtdilemma.py

@@ -0,0 +1,1062 @@
+# phase\Student_view\games\debtdilemma.py
+import streamlit as st
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Literal
+import random
+import math
+import os, time
+from utils import api as backend
+from utils import db as dbapi
+
+DISABLE_DB = os.getenv("DISABLE_DB", "1") == "1"
+
+def load_css(file_name: str):
+    try:
+        with open(file_name, "r", encoding="utf-8") as f:
+            st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+    except FileNotFoundError:
+        st.warning("⚠️ Stylesheet not found. Please ensure 'assets/styles.css' exists.")
+
+
+def _refresh_global_xp():
+    user = st.session_state.get("user")
+    if not user:
+        return
+    try:
+        stats = backend.user_stats(user["user_id"]) if DISABLE_DB else dbapi.user_xp_and_level(user["user_id"])
+        st.session_state.xp = stats.get("xp", st.session_state.get("xp", 0))
+        st.session_state.streak = stats.get("streak", st.session_state.get("streak", 0))
+    except Exception as e:
+        st.warning(f"XP refresh failed: {e}")
+
+
+DD_SCOPE_CLASS = "dd-scope"  
+
+def _ensure_dd_css():
+    """Inject CSS for Debt Dilemma buttons once, scoped under .dd-scope."""
+    
+    if st.session_state.get("_dd_css_injected"):
+        return
+    st.session_state["_dd_css_injected"] = True
+
+   
+    st.markdown("""
+    <style>
+      .dd-scope .stButton > button {
+        border: none;
+        border-radius: 25px;
+        padding: 0.75rem 1.5rem;
+        font-weight: 700;
+        box-shadow: 0 4px 15px rgba(0,0,0,.2);
+        transition: all .3s ease;
+      }
+      .dd-scope .stButton > button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 6px 20px rgba(0,0,0,.3);
+      }
+      .dd-scope .dd-success .stButton > button {
+        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+        color: #fff;
+      }
+      .dd-scope .dd-warning .stButton > button {
+        background: linear-gradient(135deg, #fa709a 0%, #fee140 100%);
+        color: #000;
+      }
+      .dd-scope .dd-danger .stButton > button {
+        background: linear-gradient(135deg, #ff6b6b 0%, #ffa500 100%);
+        color: #000;
+      }
+      .dd-scope .dd-neutral .stButton > button {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: #fff;
+      }
+    </style>
+    """, unsafe_allow_html=True)
+
+def buttondd(label: str, *, key: str, variant: str = "neutral", **kwargs) -> bool:
+    """
+     Scoped button wrapper. Use just like st.button but styles are limited to the Debt Dilemma container.
+
+    Example:
+      buttondd("Pay", key="btn_pay", variant="success", on_click=fn, use_container_width=True)
+    """
+    _ensure_dd_css()
+   
+    st.markdown(f'<div class="dd-{variant}">', unsafe_allow_html=True)
+    clicked = st.button(label, key=key, **kwargs)
+    st.markdown('</div>', unsafe_allow_html=True)
+    return clicked
+
+
+setattr(st, "buttondd", buttondd)
+
+
+# ==== Currency & economy tuning ====
+CURRENCY = "JMD$"
+MONEY_SCALE = 1000  # 1 "game dollar" = 1,000 JMD
+
+def jmd(x: int | float) -> int:
+    """Scale a base unit to JMD integer."""
+    return int(round(x * MONEY_SCALE))
+
+def fmt_money(x: int | float) -> str:
+    """Format with thousands separator and currency."""
+    #  round instead of floor so UI doesn't show 0 while a tiny positive remains
+    return f"{CURRENCY}{int(round(x)):,}"
+
+def clamp_money(x: float) -> int:
+    """Round to nearest JMD and never go negative."""
+    #  helper to normalize all balances to integer JMD
+    return max(0, int(round(x)))
+
+# Fees (scaled)
+LATE_FEE_BASE = jmd(10)   # ~JMD$10,000
+LATE_FEE_PER_MISS = jmd(5)  # +JMD$5,000 per missed
+EMERGENCY_FEE = jmd(25)   # ~JMD$25,000
+SMALL_PROC_FEE = jmd(2)   # ~JMD$2,000 for event shortfalls
+
+# ==== Starting wallet config ====
+START_WALLET_MIN = 0
+START_WALLET_MAX = jmd(10)  # JMD $0–10,000
+DISBURSE_LOAN_TO_WALLET = False  # keep loan off-wallet by default (e.g., pays tuition)
+
+# --- Credit-score tuning ---
+CS_EVENT_DECLINE_MIN = 15   # min points to deduct when you skip an expense event
+CS_EVENT_DECLINE_MAX = 100  # max points
+CS_EVENT_DECLINE_PER_K = 5  # ~5 pts per JMD$1,000 of expense you duck
+CS_EMERGENCY_EVENT_HIT = 60 # when an event forces an emergency loan
+
+# --- Utilities month-end penalties ---
+UTILITY_NONPAY_CS_HIT = 25
+UTILITY_NONPAY_HAPPY_HIT = 8
+UTILITY_RECONNECT_FEE = jmd(2)  # ~JMD$2,000 added to debt
+
+# ===============================
+# Types
+# ===============================
+@dataclass
+class LoanDetails:
+    principal: int
+    interestRate: float
+    monthlyPayment: int
+    totalOwed: float
+    monthsPaid: int
+    totalMonths: int
+    missedPayments: int
+    creditScore: int
+
+@dataclass
+class RandomEvent:
+    id: str
+    title: str
+    description: str
+    icon: str
+    type: Literal['opportunity','expense','penalty','bonus']
+    impact: Dict[str, int] = field(default_factory=dict)
+    choices: Optional[Dict[str,str]] = None
+
+@dataclass
+class GameLevel:
+    level: int
+    name: str
+    loanAmount: int
+    interestRate: float
+    monthlyPayment: int
+    totalMonths: int
+    startingIncome: int
+    description: str
+
+# ===============================
+# Data (shorter game: 3 levels)
+# ===============================
+GAME_LEVELS: List[GameLevel] = [
+    GameLevel(1, "🎓 Student Loan", jmd(100), 0.15, jmd(25), 3, jmd(120), "Your first small loan as a student - let's learn together! 📚"),
+    GameLevel(2, "🚗 Car Loan", jmd(250), 0.18, jmd(50), 3, jmd(140), "Buying your first car - bigger responsibility but you've got this! 🌟"),
+    GameLevel(3, "💳 Credit Card Debt", jmd(400), 0.22, jmd(70), 3, jmd(160), "High-interest credit card debt - time to be extra careful! ⚠️"),
+]
+
+# Replaced 'Clothes' with 'Snacks' and added happiness boosts
+EXPENSES = [
+    {"id": "food", "name": "Food", "amount": jmd(0.9), "required": True, "healthImpact": -15, "emoji": "🍎"},       # ~JMD$900 per day
+    {"id": "transport", "name": "Transport", "amount": jmd(0.5), "required": True, "healthImpact": 0, "emoji": "🚌"}, # ~JMD$500
+    {"id": "utilities", "name": "Utilities", "amount": jmd(7), "required": True, "healthImpact": -5, "emoji": "💡"},  # ~JMD$7,000/mo
+    {"id": "entertainment","name": "Entertainment","amount": jmd(1.5), "required": False, "healthImpact": 0, "happinessBoost": 5, "emoji": "🎮"},
+    {"id": "snacks", "name": "Snacks", "amount": jmd(0.8), "required": False, "healthImpact": 0, "happinessBoost": 5, "emoji": "🍿"},
+]
+
+LEVEL_EVENT_POOL = {
+    1: [  # Student Loan level
+        RandomEvent("games_day", "🏟️ School Games Day", "Your school is holding Games Day. Small fee, but huge fun and morale!", "🏟️", "expense",
+                    {"wallet": -jmd(2), "happiness": 5}, {"accept": f"Join ({fmt_money(jmd(2))}, +5% happy)", "decline": "Skip"}),
+        RandomEvent("book_fair", "📚 Book Fair", "Discounted textbooks help your grades (and future pay!).", "📚", "opportunity",
+                    {"wallet": -jmd(3), "income": jmd(1), "happiness": 3}, {"accept": "Buy books", "decline": "Pass"}),
+        RandomEvent("tuition_deadline", "🎓 Tuition Deadline", "A small admin fee pops up unexpectedly.", "🎓", "expense",
+                    {"wallet": -jmd(3.5)}, {"accept": "Pay fee", "decline": "Appeal"}),
+    ],
+    2: [  # Car Loan level
+        RandomEvent("gas_hike", "⛽ Gas Price Hike", "Fuel costs rise this week.", "⛽", "expense",
+                    {"wallet": -jmd(2.5)}, {"accept": "Buy gas", "decline": "Drive less"}),
+        RandomEvent("oil_change", "🛠️ Discount Oil Change", "Maintenance now saves larger repair later.", "🛠️", "opportunity",
+                    {"wallet": -jmd(3), "creditScore": 5}),
+    ],
+    3: [  # Credit Card level
+        RandomEvent("flash_sale", "🛍️ Flash Sale Temptation", "Limited-time sale! Tempting but watch your debt.", "🛍️", "penalty",
+                    {"debt": jmd(4), "happiness": 4}, {"accept": "Buy (+debt)", "decline": "Resist"}),
+        RandomEvent("cashback", "💳 Cashback Bonus", "Your card offers a cashback promo.", "💳", "bonus",
+                    {"wallet": jmd(3)}),
+    ],
+}
+
+EVENT_POOL: List[RandomEvent] = [
+    # Money-earning opportunities
+    RandomEvent("yard_sale", "🧹 Yard Sale Fun!", "You sell old items and make some quick cash! Great job being resourceful! 🌟", "🧹", "opportunity", {"wallet": jmd(6)}),
+    RandomEvent("tutoring", "📚 Tutoring Helper", "You help someone with homework and get paid! Sharing knowledge feels great! 😊", "📚", "opportunity", {"wallet": jmd(5)}),
+    RandomEvent("odd_jobs", "🧰 Weekend Helper", "You mow lawns and wash a car over the weekend! Hard work pays off! 💪", "🧰", "opportunity", {"wallet": jmd(7)}),
+
+    # Bonuses / grants
+    RandomEvent("overtime_work", "💼 Extra Work Time", "Your boss offers you overtime this period. Extra money but you'll be tired! 😴", "💼", "opportunity",
+                {"wallet": jmd(8)}, {"accept": f"Work overtime (+{fmt_money(jmd(8))}) 💪", "decline": "Rest instead 😴"}),
+    RandomEvent("freelance_job", "💻 Weekend Project", "A friend asks you to help with their business for some quick cash! 🤝", "💻", "opportunity",
+                {"wallet": jmd(6)}, {"accept": f"Take the job (+{fmt_money(jmd(6))}) 💼", "decline": "Enjoy your weekend 🌈"}),
+    RandomEvent("bonus_payment", "⭐ Amazing Work!", "Your excellent work this period earned you a bonus! You're doing great! 🎉", "⭐", "bonus", {"wallet": jmd(5), "creditScore": 10}),
+    RandomEvent("scholarship_opportunity", "🎓 Learning Reward", "You qualify for a small educational grant! Knowledge pays off! 📖", "🎓", "bonus", {"wallet": jmd(10), "income": jmd(2)}),
+
+    # Health & happiness helpers
+    RandomEvent("mental_health", "🧠 Feeling Better", "A free counseling session can help you feel better and happier! 🌈", "🧠", "opportunity",
+                {"wallet": 0, "health": 10, "happiness": 10}, {"accept": "Feel better! 😊", "decline": "Maybe later 🤔"}),
+    RandomEvent("health_checkup", "🏥 Health Check", "Local clinic does a free health checkup! Taking care of yourself is important! 💚", "🏥", "opportunity",
+                {"wallet": 0, "health": 10, "happiness": 5}, {"accept": "Get healthy! 💪", "decline": "Skip it 🤷"}),
+
+    # Expenses / penalties
+    RandomEvent("landlord_eviction", "🏠 Moving Costs", "You need a small deposit for a new place soon. Moving can be expensive! 📦", "🏠", "expense",
+                {"wallet": -jmd(9)}, {"accept": f"Pay deposit (-{fmt_money(jmd(9))}) 🏠", "decline": "Try to negotiate 🤝"}),
+    RandomEvent("transport_breakdown", "🚫 Transport Trouble", "Your usual transport is down. You need an alternative way to get around! 🚶", "🚫", "expense",
+                {"wallet": -jmd(3)}, {"accept": f"Pay for ride (-{fmt_money(jmd(3))}) 🚗", "decline": "Walk everywhere 🚶"}),
+    RandomEvent("utilities_shutoff", "⚡ Utility Warning", "Utilities will be shut off if not paid soon! Don't let the lights go out! 💡", "⚡", "expense",
+                {"wallet": -jmd(4)}, {"accept": f"Pay now (-{fmt_money(jmd(4))}) 💡", "decline": "Risk it 😬"}),
+]
+
+# ===============================
+# Helpers
+# ===============================
+def get_level(level:int) -> GameLevel:
+    return GAME_LEVELS[level-1]
+
+def required_expenses_total() -> int:
+    return sum(e["amount"] for e in EXPENSES if e["required"])
+
+def progress_percent(total_owed: float, monthly_payment: int, total_months: int) -> float:
+    pct = ((total_months - (total_owed / max(monthly_payment,1))) / total_months) * 100
+    return max(0.0, min(100.0, pct))
+
+def payoff_projection(balance: float, apr: float, monthly_payment: int):
+    """
+    Simulate payoff using the game's timing:
+    - Player pays during the month (before interest).
+    - At month end, interest accrues on the remaining balance and is added.
+    Returns (months_needed, total_interest_paid). If payment <= interest, returns (None, None).
+    """
+    r = apr / 12.0
+    if balance <= 0:
+        return 0, 0
+    if r <= 0:
+        months = math.ceil(balance / max(1, monthly_payment))
+        return months, 0
+    if monthly_payment <= balance * r:
+        return None, None
+    months = 0
+    total_interest = 0.0
+    b = float(balance)
+    for _ in range(10000):  # safety cap
+        pay = min(monthly_payment, b)
+        b -= pay
+        months += 1
+        if b <= 1e-6:
+            break
+        interest = b * r
+        b += interest
+        total_interest += interest
+        if monthly_payment <= b * r - 1e-9:
+            return None, None
+    return months, int(round(total_interest))
+
+
+def _award_level_completion_if_needed():
+    """Give exactly +50 XP once per completed level, including the last level."""
+    user = st.session_state.get("user")
+    if not user:
+        return
+    lvl = int(st.session_state.currentLevel)
+    key = f"_dd_xp_awarded_L{lvl}"
+    if st.session_state.get(key):
+        return  # already awarded for this level
+
+    try:
+        # compute elapsed time for the level
+        start_ts = st.session_state.get("dd_start_ts", time.time())
+        elapsed_ms = int(max(0, (time.time() - start_ts) * 1000))
+
+        if DISABLE_DB:
+            # call backend Space
+            backend.record_debt_dilemma_play(
+                user_id=user["user_id"],
+                loans_cleared=1,  # you completed the level
+                mistakes=int(st.session_state.loan.missedPayments),
+                elapsed_ms=elapsed_ms,
+                gained_xp=50,
+            )
+        else:
+            # local DB path kept for dev mode
+            dbapi.record_debt_dilemma_round(
+                user["user_id"],
+                level=lvl,
+                round_no=0,
+                wallet=int(st.session_state.wallet),
+                health=int(st.session_state.health),
+                happiness=int(st.session_state.happiness),
+                credit_score=int(st.session_state.loan.creditScore),
+                event_json={"phase": st.session_state.gamePhase},
+                outcome=("level_complete" if st.session_state.gamePhase == "level-complete" else "game_complete"),
+                gained_xp=50,
+                elapsed_ms=elapsed_ms,
+            )
+
+        st.session_state[key] = True
+        _refresh_global_xp()
+        st.success("Saved +50 XP for completing this loan")
+    except Exception as e:
+        st.error(f"Could not save completion XP: {e}")
+
+
+def check_loan_completion() -> bool:
+    """Advance level or finish game when loan is cleared. Returns True if game phase changed."""
+    loan = st.session_state.loan
+    #  use integerized check; tiny float dust won't block completion
+    if clamp_money(loan.totalOwed) == 0:
+        if st.session_state.currentLevel < len(GAME_LEVELS):
+            st.session_state.gamePhase = "level-complete"
+            st.toast(f"Level {st.session_state.currentLevel} complete! Ready for next?")
+        else:
+            st.session_state.gamePhase = "completed"
+            st.toast("All levels done! 🎉")
+        return True
+    return False
+
+def init_state():
+    if "gamePhase" not in st.session_state:
+        st.session_state.update({
+            "gamePhase": "setup",
+            "currentMonth": 1,
+            "currentDay": 1,
+            "daysInMonth": 28,
+            "roundsLeft": 6,
+            "wallet": random.randint(START_WALLET_MIN, START_WALLET_MAX),
+            "monthlyIncome": GAME_LEVELS[0].startingIncome,
+            "health": 100,
+            "happiness": 100,
+            "monthsWithoutFood": 0,
+            "currentEvent": None,
+            "eventHistory": [],
+            "difficultyMultiplier": 1.0,
+            "currentLevel": 1,
+            "paidExpenses": [],
+            "hasWorkedThisMonth": False,
+            "achievements": [],
+            "lastWorkPeriod": 0,
+            "amountPaidThisMonth": 0,
+            "fullPaymentMadeThisMonth": False,
+            "paidFoodToday": False,
+        })
+        lvl = get_level(1)
+        st.session_state["loan"] = LoanDetails(
+            principal=lvl.loanAmount,
+            interestRate=lvl.interestRate,
+            monthlyPayment=lvl.monthlyPayment,
+            totalOwed=float(lvl.loanAmount),
+            monthsPaid=0,
+            totalMonths=lvl.totalMonths,
+            missedPayments=0,
+            creditScore=random.randint(200, 600),
+        )
+        if "dd_start_ts" not in st.session_state:
+            st.session_state.dd_start_ts = time.time()
+
+# Fortnight helper (every 2 weeks)
+def current_fortnight() -> int:
+    return 1 + (st.session_state.currentDay - 1) // 14
+
+# ===== End checks =====
+def check_end_conditions() -> bool:
+    if st.session_state.health <= 0:
+        st.session_state.health = 0
+        st.session_state.gamePhase = "hospital"
+        st.toast("You've been hospitalized! Health reached 0%. Game Over.")
+        return True
+    if st.session_state.happiness <= 0:
+        st.session_state.happiness = 0
+        st.session_state.gamePhase = "burnout"
+        st.toast("Happiness reached 0%. You gave up. Game Over.")
+        return True
+    return False
+
+# ===== Day advancement =====
+def advance_day(no_event: bool = False):
+    """Advance one day. If no_event=True, skip daily event roll (use when an action already consumed the day)."""
+    if st.session_state.gamePhase == "repaying":
+        if not st.session_state.paidFoodToday:
+            st.session_state.health = max(0, st.session_state.health - 5)
+            st.toast("You skipped food today. Health -5%")
+        st.session_state.paidFoodToday = False
+
+    if not no_event and st.session_state.gamePhase == "repaying" and st.session_state.currentEvent is None:
+        new_evt = gen_random_event()
+        if new_evt:
+            st.session_state.currentEvent = new_evt
+            st.toast(f"New event: {new_evt.title}")
+            return
+
+    if check_end_conditions():
+        return
+
+    st.session_state.currentDay += 1
+    if st.session_state.currentDay > st.session_state.daysInMonth:
+        st.session_state.currentDay = 1
+        next_month()
+    else:
+        st.toast(f"Day {st.session_state.currentDay}/{st.session_state.daysInMonth}")
+
+def fast_forward_to_month_end():
+    st.toast("Skipping to month end…")
+    st.session_state.currentDay = st.session_state.daysInMonth
+    next_month()
+
+# ===============================
+# Random events
+# ===============================
+def set_event(evt: Optional[RandomEvent]):
+    st.session_state["currentEvent"] = evt
+
+def gen_random_event() -> Optional[RandomEvent]:
+    currentMonth = st.session_state.currentMonth
+    difficulty = st.session_state.difficultyMultiplier
+    base = 0.08
+    eventChance = min(base + (currentMonth * 0.03) + (difficulty * 0.02), 0.4)
+    if random.random() < eventChance:
+        seen = set(st.session_state.eventHistory)
+        level_specific = LEVEL_EVENT_POOL.get(st.session_state.currentLevel, [])
+        pool = EVENT_POOL + level_specific
+        available = [e for e in pool if (e.id not in seen) or (e.type in ("opportunity","bonus"))]
+        if available:
+            return random.choice(available)
+    return None
+
+# ===============================
+# Game actions
+# ===============================
+def start_loan():
+    st.session_state.dd_start_ts = time.time()   # start elapsed timer
+    st.session_state.gamePhase = "repaying"
+    if DISBURSE_LOAN_TO_WALLET:
+        st.session_state.wallet += st.session_state.loan.principal
+        st.toast(f"Loan approved! {fmt_money(st.session_state.loan.principal)} added to your wallet.")
+    else:
+        st.toast("Loan approved! Funds go directly to fees (not your wallet).")
+
+def do_skip_payment():
+    loan: LoanDetails = st.session_state.loan
+    loan.missedPayments += 1
+    loan.creditScore = max(300, loan.creditScore - 50)
+    st.toast("Payment missed! Credit score -50.")
+    advance_day(no_event=False)
+
+def can_work_this_period() -> bool:
+    return st.session_state.lastWorkPeriod != current_fortnight()
+
+WORK_HAPPINESS_COST = 10
+WORK_MIN = jmd(6)  # ~JMD$6,000
+WORK_VAR = jmd(3)  # up to +JMD$3,000
+
+def do_work_for_money():
+    if not can_work_this_period():
+        st.toast("You already worked this fortnight. Try later.")
+        return
+    earnings = WORK_MIN + random.randint(0, WORK_VAR)
+    st.session_state.wallet += earnings
+    st.session_state.happiness = max(0, st.session_state.happiness - WORK_HAPPINESS_COST)
+    st.session_state.hasWorkedThisMonth = True
+    st.session_state.lastWorkPeriod = current_fortnight()
+    st.toast(f"Work done! +{fmt_money(earnings)}, Happiness -{WORK_HAPPINESS_COST} (uses 1 day)")
+    if st.session_state.happiness <= 30 and "workaholic" not in st.session_state.achievements:
+        st.session_state.achievements.append("workaholic")
+        st.toast("Achievement: Workaholic - Worked while happiness was low!")
+    if not check_end_conditions():
+        advance_day(no_event=True)
+
+def do_make_payment_full():
+    make_payment(st.session_state.loan.monthlyPayment)
+
+def do_make_payment_partial():
+    #  use ceil so a tiny remainder (e.g., 0.4 JMD) can be fully cleared
+    leftover = math.ceil(st.session_state.loan.totalOwed)
+    pay_what = max(0, min(st.session_state.wallet - required_expenses_total(), leftover))
+    make_payment(pay_what)
+
+def make_payment(amount: int):
+    loan: LoanDetails = st.session_state.loan
+    required_total = required_expenses_total()
+    if amount <= 0:
+        st.toast("Enter a valid payment amount.")
+        return
+    if st.session_state.wallet >= amount and st.session_state.wallet - amount >= required_total:
+        st.session_state.wallet -= amount
+        #  clamp debt after payment to eliminate float dust
+        loan.totalOwed = clamp_money(loan.totalOwed - amount)
+        st.session_state.amountPaidThisMonth += amount
+        if amount >= loan.monthlyPayment:
+            loan.monthsPaid += 1
+            st.session_state.fullPaymentMadeThisMonth = True
+            st.toast(f"Payment successful! {fmt_money(amount)} paid.")
+        else:
+            still = max(0, loan.monthlyPayment - amount)
+            st.toast(f"Partial payment {fmt_money(amount)}. Need {fmt_money(still)} more for full.")
+        #  rely on integerized zero check
+        if check_loan_completion():
+            return
+        if st.session_state.gamePhase == "repaying":
+            advance_day(no_event=True)
+    else:
+        st.toast("Not enough money (remember mandatory expenses).")
+
+# Paying expenses is free; Food heals
+def pay_expense(expense: Dict):
+    if st.session_state.wallet >= expense["amount"]:
+        st.session_state.wallet -= expense["amount"]
+        if expense["id"] not in st.session_state.paidExpenses:
+            st.session_state.paidExpenses.append(expense["id"])
+        st.toast(f"Paid {fmt_money(expense['amount'])} for {expense['name']}")
+        boost = int(expense.get("happinessBoost", 0))
+        if boost:
+            before = st.session_state.happiness
+            st.session_state.happiness = min(100, st.session_state.happiness + boost)
+            st.toast(f"Happiness +{st.session_state.happiness - before}%")
+        if expense["id"] == "food":
+            st.session_state.paidFoodToday = True
+            before_h = st.session_state.health
+            st.session_state.health = min(100, st.session_state.health + 10)
+            healed = st.session_state.health - before_h
+            if healed > 0:
+                st.toast(f"Health +{healed}% from eating well")
+        if expense["id"] == "utilities":
+            before = st.session_state.happiness
+            st.session_state.happiness = max(0, st.session_state.happiness - 3)
+            st.toast(f"Happiness -{before - st.session_state.happiness}% (paid utilities)")
+        check_end_conditions()
+    else:
+        st.toast(f"Can't afford {expense['name']}! It will be auto-deducted at month end.")
+
+# Resolving events: consumes 1 day
+def handle_event_choice(accept: bool):
+    evt: Optional[RandomEvent] = st.session_state.currentEvent
+    if not evt:
+        return
+    loan: LoanDetails = st.session_state.loan
+
+    if accept and evt.impact:
+        if "wallet" in evt.impact:
+            delta = evt.impact["wallet"]
+            if delta < 0 and st.session_state.wallet < abs(delta):
+                st.toast("You can't afford this! Emergency loan taken.")
+                short = abs(delta) + SMALL_PROC_FEE
+                st.session_state.wallet = 0
+                #  clamp after adding emergency shortfall
+                loan.totalOwed = clamp_money(loan.totalOwed + short)
+                loan.creditScore = max(300,loan.creditScore - CS_EMERGENCY_EVENT_HIT)
+                st.toast(f"Added to debt: {fmt_money(short)}")
+            else:
+                st.session_state.wallet += delta
+                st.toast(f"{'+' if delta>0 else ''}{fmt_money(delta)} {'earned' if delta>0 else 'spent'}.")
+        if "income" in evt.impact:
+            st.session_state.monthlyIncome = max(jmd(0.05), st.session_state.monthlyIncome + evt.impact["income"])
+        if "creditScore" in evt.impact:
+            loan.creditScore = max(300, min(850, loan.creditScore + evt.impact["creditScore"]))
+        if "debt" in evt.impact:
+            #  clamp after debt increase from event
+            loan.totalOwed = clamp_money(loan.totalOwed + evt.impact["debt"])
+        if "health" in evt.impact:
+            st.session_state.health = min(100, max(0, st.session_state.health + evt.impact["health"]))
+        if "happiness" in evt.impact:
+            st.session_state.happiness = min(100, max(0, st.session_state.happiness + evt.impact["happiness"]))
+    elif not accept:
+        if evt.type == "expense":
+            st.toast("You avoided the expense but there might be consequences…")
+            if random.random() < 0.5 and "wallet" in evt.impact:
+                base_k = abs(evt.impact["wallet"]) / MONEY_SCALE  # convert JMD → 'thousands'
+                penalty = int(round(base_k * CS_EVENT_DECLINE_PER_K))
+                penalty = max(CS_EVENT_DECLINE_MIN, min(CS_EVENT_DECLINE_MAX, penalty))
+                loan.creditScore = max(300, loan.creditScore - penalty)
+                st.toast(f"Credit score penalty: -{penalty}")
+        else:
+            st.toast("You declined the opportunity.")
+
+    st.session_state.eventHistory.append(evt.id)
+    st.session_state.difficultyMultiplier += 0.1
+    st.session_state.currentEvent = None
+    if not check_end_conditions():
+        advance_day(no_event=True)
+
+# ===============================
+# Month processing
+# ===============================
+def check_achievements():
+    if st.session_state.health == 100 and "perfect-health" not in st.session_state.achievements:
+        st.session_state.achievements.append("perfect-health")
+        st.toast("Achievement: Perfect Health!")
+    if st.session_state.health <= 20 and "survivor" not in st.session_state.achievements:
+        st.session_state.achievements.append("survivor")
+        st.toast("Achievement: Survivor!")
+    if st.session_state.happiness >= 90 and "happy-camper" not in st.session_state.achievements:
+        st.session_state.achievements.append("happy-camper")
+        st.toast("Achievement: Happy Camper!")
+    if st.session_state.wallet <= jmd(0.01) and st.session_state.happiness >= 50 and "broke-not-broken" not in st.session_state.achievements:
+        st.session_state.achievements.append("broke-not-broken")
+        st.toast("Achievement: Broke But Not Broken!")
+    if st.session_state.loan.creditScore >= 800 and "credit-master" not in st.session_state.achievements:
+        st.session_state.achievements.append("credit-master")
+        st.toast("Achievement: Credit Master!")
+
+def next_month():
+    loan: LoanDetails = st.session_state.loan
+    st.session_state.lastWorkPeriod = 0
+
+    if st.session_state.gamePhase == "repaying":
+        if not st.session_state.fullPaymentMadeThisMonth:
+            loan.missedPayments += 1
+            st.toast("You missed this month’s full payment.")
+        st.session_state.amountPaidThisMonth = 0
+        st.session_state.fullPaymentMadeThisMonth = False
+
+        unpaid = [e for e in EXPENSES if e["required"] and e["id"] not in st.session_state.paidExpenses]
+        total_forced = sum(e["amount"] for e in unpaid)
+        total_health_loss = sum(abs(e.get("healthImpact", 0)) for e in unpaid)
+
+        if total_forced > 0:
+            if st.session_state.wallet >= total_forced:
+                st.session_state.wallet -= total_forced
+                st.session_state.health = max(0, st.session_state.health - total_health_loss)
+                st.toast(f"Mandatory expenses auto-deducted: {fmt_money(total_forced)}, Health -{total_health_loss}")
+            else:
+                shortfall = total_forced - st.session_state.wallet
+                st.session_state.wallet = 0
+                st.session_state.health = max(0, st.session_state.health - total_health_loss - 10)
+                #  clamp after emergency shortfall + fee
+                loan.totalOwed = clamp_money(loan.totalOwed + shortfall + EMERGENCY_FEE)
+                loan.creditScore = max(300, loan.creditScore - 35)
+                st.toast(f"Couldn't afford mandatory expenses! Emergency loan: {fmt_money(shortfall + EMERGENCY_FEE)}, Health -{total_health_loss + 10}")
+
+        if st.session_state.currentLevel >= 3 and st.session_state.wallet < st.session_state.monthlyIncome * 0.5:
+            loss = int(((st.session_state.monthlyIncome * 0.5) - st.session_state.wallet) / jmd(1))
+            if loss > 0:
+                st.session_state.happiness = max(0, st.session_state.happiness - loss)
+                st.toast(f"Low funds affecting mood! Happiness -{loss}")
+
+        st.session_state.currentMonth += 1
+        st.session_state.currentDay = 1
+        st.session_state.roundsLeft -= 1
+        st.session_state.wallet += st.session_state.monthlyIncome
+        st.session_state.paidExpenses = []
+        st.session_state.hasWorkedThisMonth = False
+
+        if st.session_state.roundsLeft <= 0:
+            st.toast("Time's up! You ran out of rounds!")
+            st.session_state.gamePhase = "completed"
+            return
+
+        if loan.missedPayments > 0:
+            late_fee = LATE_FEE_BASE + (loan.missedPayments * LATE_FEE_PER_MISS)
+            #  clamp after applying late fees
+            loan.totalOwed = clamp_money(loan.totalOwed + late_fee)
+            st.toast(f"Late fee applied: {fmt_money(late_fee)}")
+            loan.missedPayments = 0
+
+        # Extra month-end consequences if Utilities weren't paid
+        unpaid_ids = {e["id"] for e in unpaid}
+        if "utilities" in unpaid_ids:
+            # Credit score & happiness hit + reconnection fee
+            loan.creditScore = max(300, loan.creditScore - UTILITY_NONPAY_CS_HIT)
+            st.session_state.happiness = max(0, st.session_state.happiness - UTILITY_NONPAY_HAPPY_HIT)
+            #  clamp after reconnect fee
+            loan.totalOwed = clamp_money(loan.totalOwed + UTILITY_RECONNECT_FEE)
+            st.toast(
+                f"Utilities unpaid: Credit -{UTILITY_NONPAY_CS_HIT}, "
+                f"Happiness -{UTILITY_NONPAY_HAPPY_HIT}, "
+                f"Reconnect fee {fmt_money(UTILITY_RECONNECT_FEE)}"
+            )
+
+        check_achievements()
+
+        if st.session_state.gamePhase == "repaying":
+            #  integerize monthly interest and clamp new total
+            monthly_interest = clamp_money((loan.totalOwed * loan.interestRate) / 12.0)
+            loan.totalOwed = clamp_money(loan.totalOwed + monthly_interest)
+            #  ensure completion triggers even after month-end math
+            check_loan_completion()
+
+        st.toast(f"Month {st.session_state.currentMonth}: +{fmt_money(st.session_state.monthlyIncome)} income. {st.session_state.roundsLeft} rounds left.")
+        check_end_conditions()
+
+# ===============================
+# UI
+# ===============================
+def header():
+    level = get_level(st.session_state.currentLevel)
+    base_payday_hint = "Paid at month end"
+    st.markdown(f"""
+      <div class="game-header">
+        <div class="game-title">🎮 Debt Dilemma 💳</div>
+        <h3>Month {st.session_state.currentMonth} · Day {st.session_state.currentDay}/{st.session_state.daysInMonth}</h3>
+        <p>Level {st.session_state.currentLevel}: {level.name}</p>
+      </div>
+    """, unsafe_allow_html=True)
+
+    st.markdown(f"""
+      <div class="metric-card">
+        <h3>📊 Your Status</h3>
+        <div style="display:flex;flex-wrap:wrap;gap:1rem;justify-content:space-between;margin-top:1rem;">
+          <div><strong>💰 Wallet:</strong> {fmt_money(st.session_state.wallet)}</div>
+          <div><strong>💼 Base Salary:</strong> {fmt_money(st.session_state.monthlyIncome)} <small>({base_payday_hint})</small></div>
+          <div><strong>📊 Credit:</strong> {st.session_state.loan.creditScore}</div>
+          <div><strong>❤️ Health:</strong> {st.session_state.health}%</div>
+          <div><strong>😊 Happy:</strong> {st.session_state.happiness}%</div>
+        </div>
+        <div style="margin-top:.5rem;">
+          <small>💡 “Work for Money” is extra: once per fortnight you can earn ~JMD$6k–9k for 1 day, and it lowers happiness by 10%.</small>
+        </div>
+      </div>
+    """, unsafe_allow_html=True)
+
+def setup_screen():
+    level = get_level(st.session_state.currentLevel)
+
+    # --- Header ---
+    st.markdown(f"""
+      <div class="game-header">
+        <div class="game-title">🎯 Level {level.level}: {level.name}</div>
+        <p>{level.description}</p>
+      </div>
+    """, unsafe_allow_html=True)
+
+    # --- Loan Info ---
+    months_est, interest_est = payoff_projection(
+        balance=float(level.loanAmount),
+        apr=level.interestRate,
+        monthly_payment=level.monthlyPayment
+    )
+    if months_est is None:
+        proj_html = "<small>🧮 Projection: Payment too low — balance will grow.</small>"
+    else:
+        years_est = months_est / 12.0
+        proj_html = (f"<small>🧮 Projection: ~{months_est} payments (~{years_est:.1f} years), "
+                     f"est. interest {fmt_money(interest_est)}</small>")
+
+    st.markdown("### 📋 Loan Details")
+    st.markdown(f"""
+      <div class="metric-card">
+        <h3>💳 Loan Information</h3>
+        <div style="display:grid;grid-template-columns:1fr 1fr;gap:1rem;margin-top:1rem;">
+          <div><strong>💰 Amount:</strong> {fmt_money(level.loanAmount)}</div>
+          <div><strong>📈 Interest:</strong> {int(level.interestRate*100)}% yearly</div>
+          <div><strong>💳 Monthly Payment:</strong> {fmt_money(level.monthlyPayment)}</div>
+          <div><strong>⏰ Time Limit (target):</strong> {level.totalMonths} months</div>
+        </div>
+        <div style="margin-top:.5rem;">{proj_html}</div>
+      </div>
+    """, unsafe_allow_html=True)
+
+    # --- Player situation ---
+    st.markdown("### 🌟 Your Current Situation")
+    st.markdown(f"""
+      <div class="metric-card">
+        <h3>💼 Your Financial Status</h3>
+        <div style="display:grid;grid-template-columns:1fr 1fr;gap:1rem;margin-top:1rem;">
+          <div><strong>💰 Wallet (random start):</strong> {fmt_money(st.session_state.wallet)}</div>
+          <div><strong>💼 Base Salary (month end):</strong> {fmt_money(st.session_state.monthlyIncome)}</div>
+          <div><strong>🏠 Required Expenses (per month):</strong> {fmt_money(required_expenses_total())}</div>
+          <div><strong>📊 Credit Score:</strong> {st.session_state.loan.creditScore}</div>
+        </div>
+        <div style="margin-top:.5rem;">
+          <small>💡 You get your <strong>base salary automatically at month end</strong>. The <em>Work for Money</em> button gives <strong>extra</strong> cash (~JMD$6k–9k) and can be used <strong>once per fortnight</strong> (costs 1 day, -10% happiness).</small>
+        </div>
+      </div>
+    """, unsafe_allow_html=True)
+
+    st.markdown("""
+    ### 🎮 Game Rules - Let's Learn Together!
+    🎯 **Your Mission:** Pay off your loan while staying healthy and happy!
+
+    📚 **Important Rules:**
+    - 💰 Interest grows your debt each month - pay on time!
+    - ❤️ Health 0% = hospital visit (game over!)
+    - 😊 Happiness 0% = you give up (game over!)
+    - 🍎 Food keeps you healthy (+10 health when paid!)
+    - 🎮 Entertainment & 🍿 Snacks make you happy (+5% each!)
+    - 🎲 Random events happen daily - some good, some challenging!
+
+    ⏰ **Time Costs:**
+    - 💼 Work (extra) = 1 day (**once per fortnight**)
+    - 💳 Make loan payment = 1 day
+    - 🎲 Handle events = 1 day
+    - 🏠 Paying expenses = FREE (no time cost!)
+
+    💡 **Payday:** Your **base salary** hits your wallet automatically at **month end**.
+    """)
+
+    #  use st.buttondd (scoped) instead of st.button
+    st.buttondd(
+        f"🚀 Accept Level {level.level} Loan & {'Receive ' + fmt_money(level.loanAmount) if DISBURSE_LOAN_TO_WALLET else 'Start the Level'}!",
+        use_container_width=True,
+        on_click=start_loan,
+        key="btn_start_loan",
+        variant="success"
+    )
+
+def main_screen():
+    header()
+
+    left, right = st.columns([2,1])
+
+    with left:
+        evt: Optional[RandomEvent] = st.session_state.currentEvent
+        if evt:
+            st.markdown(f"""
+              <div class="event-card">
+                <div class="event-title">{evt.icon} {evt.title}</div>
+                <p>{evt.description}</p>
+              </div>
+            """, unsafe_allow_html=True)
+
+            badge_colors = {
+                "opportunity": "🌟 GREAT OPPORTUNITY!",
+                "expense": "⚠️ EXPENSE ALERT",
+                "penalty": "⛔ CHALLENGE",
+                "bonus": "🎁 AWESOME BONUS!"
+            }
+            st.success(badge_colors[evt.type])
+
+            c1, c2 = st.columns(2)
+            if evt.choices:
+                with c1:
+                    st.buttondd(evt.choices["accept"], use_container_width=True, on_click=lambda: handle_event_choice(True), key="evt_accept", variant="success")
+                with c2:
+                    st.buttondd(evt.choices["decline"], use_container_width=True, on_click=lambda: handle_event_choice(False), key="evt_decline", variant="warning")
+            else:
+                st.buttondd("✨ Continue (uses 1 day)", use_container_width=True, on_click=lambda: handle_event_choice(True), key="evt_continue", variant="success")
+
+            st.markdown("---")
+
+        # --- Loan status + payoff projection ---
+        progress = progress_percent(st.session_state.loan.totalOwed, st.session_state.loan.monthlyPayment, st.session_state.loan.totalMonths)/100
+        months_est, interest_est = payoff_projection(
+            st.session_state.loan.totalOwed,
+            st.session_state.loan.interestRate,
+            st.session_state.loan.monthlyPayment
+        )
+        if months_est is None:
+            proj_html = "<div><strong>🧮 Projection:</strong> Payment too low — balance will grow.</div>"
+        else:
+            years_est = months_est / 12.0
+            proj_html = (
+                f"<div><strong>🧮 Projection:</strong> ~{months_est} payments "
+                f"(~{years_est:.1f} years), est. interest {fmt_money(interest_est)}</div>"
+            )
+
+        st.markdown(f"""
+          <div class="metric-card">
+            <h3>💳 Loan Status</h3>
+            <div style="margin-top: 1rem;">
+              <div style="display: flex; justify-content: space-between; margin-bottom: 0.5rem;">
+                <div><strong>💰 Still Owed:</strong> {fmt_money(st.session_state.loan.totalOwed)}</div>
+                <div><strong>💳 Monthly Due:</strong> {fmt_money(st.session_state.loan.monthlyPayment)}</div>
+              </div>
+              {proj_html}
+              <div style="margin: 1rem 0;">
+                <div style="background: #e0e0e0; border-radius: 10px; height: 20px; overflow: hidden;">
+                  <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); height: 100%; width: {progress*100}%; border-radius: 10px;"></div>
+                </div>
+                <div style="text-align: center; margin-top: 0.5rem;"><strong>🎯 Progress: {progress*100:.1f}% Complete!</strong></div>
+              </div>
+              <div style="display: grid; grid-template-columns: repeat(2, 1fr); gap: .5rem;">
+                <div><strong>✅ Payments:</strong> {st.session_state.loan.monthsPaid}/{st.session_state.loan.totalMonths}</div>
+                <div><strong>{"⚠️" if st.session_state.loan.missedPayments > 0 else "✅"} Missed:</strong> {st.session_state.loan.missedPayments}</div>
+                <div><small>{(st.session_state.loan.interestRate*100/12):.1f}% monthly interest</small></div>
+                <div><small>📅 Paid This Month: {fmt_money(st.session_state.amountPaidThisMonth)}{" — ✅ Full" if st.session_state.fullPaymentMadeThisMonth else ""}</small></div>
+              </div>
+            </div>
+          </div>
+        """, unsafe_allow_html=True)
+
+        can_afford = st.session_state.wallet >= (st.session_state.loan.monthlyPayment + required_expenses_total())
+        #  use ceil so you can actually clear small residuals
+        pay_what = max(0, min(st.session_state.wallet - required_expenses_total(), math.ceil(st.session_state.loan.totalOwed)))
+
+        b1, b2, b3 = st.columns([2,2,2])
+        with b1:
+            st.buttondd(
+                f"💰 Full Payment (1 day) {fmt_money(st.session_state.loan.monthlyPayment)}",
+                disabled=not can_afford,
+                use_container_width=True,
+                on_click=do_make_payment_full,
+                key="btn_pay_full",
+                variant="success" if can_afford else "warning"
+            )
+        with b2:
+            st.buttondd(
+                f"💸 Pay What I Can (1 day) {fmt_money(pay_what)}",
+                disabled=pay_what<=0,
+                use_container_width=True,
+                on_click=do_make_payment_partial,
+                key="btn_pay_partial",
+                variant="success" if pay_what>0 else "warning"
+            )
+        with b3:
+            st.buttondd("⏭️ Skip Payment (1 day)", use_container_width=True, on_click=do_skip_payment, key="btn_skip", variant="danger")
+
+        st.markdown("### 🏠 Monthly Expenses (Free Actions - No Time Cost!)")
+        cols = st.columns(2)
+        for i, exp in enumerate(EXPENSES):
+            with cols[i % 2]:
+                required_text = "⚠️ Required" if exp["required"] else "🌟 Optional"
+                happiness_text = f"<br><small>😊 (+{exp.get('happinessBoost', 0)}% happiness)</small>" if exp.get('happinessBoost', 0) > 0 else ""
+                st.markdown(f"""
+                  <div class="expense-card">
+                    <h4>{exp['emoji']} {exp['name']} - {fmt_money(exp['amount'])}</h4>
+                    <p>{required_text}{happiness_text}</p>
+                  </div>
+                """, unsafe_allow_html=True)
+                disabled = st.session_state.wallet < exp["amount"]
+                st.buttondd(
+                    f"{exp['emoji']} Pay",
+                    key=f"pay_{exp['id']}",
+                    disabled=disabled,
+                    on_click=lambda e=exp: pay_expense(e),
+                    use_container_width=True,
+                    variant="success" if not disabled else "warning"
+                )
+
+        st.markdown("---")
+        label = "🌅 End Day & See What Happens!"
+        if st.session_state.currentDay == st.session_state.daysInMonth:
+            label = f"🗓️ End Month {st.session_state.currentMonth} → Payday: {fmt_money(st.session_state.monthlyIncome)}!"
+        st.buttondd(label, disabled=st.session_state.currentEvent is not None, use_container_width=True, on_click=lambda: advance_day(no_event=False), key="btn_end_day", variant="success")
+        st.buttondd("⏩ Skip to Month End (When Low on Money!)", use_container_width=True, on_click=fast_forward_to_month_end, key="btn_ff", variant="warning")
+
+    with right:
+        health_color = "🟢" if st.session_state.health > 70 else "🟡" if st.session_state.health > 30 else "🔴"
+        happiness_color = "😊" if st.session_state.happiness > 70 else "😐" if st.session_state.happiness > 30 else "😢"
+
+        net_monthly = st.session_state.monthlyIncome - required_expenses_total() - st.session_state.loan.monthlyPayment
+        net_color = "🟢" if net_monthly > 0 else "🔴"
+
+        st.markdown("### 🌟 Your Wellbeing")
+        st.markdown(f"""
+          <div class="metric-card">
+            <h3>💪 Status Overview</h3>
+            <div style="margin-top: 1rem;">
+              <div style="display: flex; justify-content: space-between; margin-bottom: 1rem;">
+                <div><strong>❤️ Health:</strong> {health_color} {st.session_state.health}%</div>
+                <div><strong>😊 Happiness:</strong> {happiness_color} {st.session_state.happiness}%</div>
+              </div>
+              <div style="text-align: center; padding: 1rem 0; border-top: 1px solid #eee;">
+                <strong>💹 Monthly Budget:</strong> {net_color} {fmt_money(net_monthly)}<br>
+                <small>After loan & required expenses</small>
+              </div>
+            </div>
+          </div>
+        """, unsafe_allow_html=True)
+
+        # Work button
+        work_available = can_work_this_period()
+        st.buttondd("💼 Work for Money! (1 day, once/fortnight)\n~JMD$6k–9k, -10% Happiness",
+                    disabled=not work_available,
+                    on_click=do_work_for_money,
+                    key="btn_work",
+                    variant="success" if work_available else "warning")
+        cur_fn = current_fortnight()
+        st.caption(f"📅 Fortnight {cur_fn}/2 — you can work once each 2 weeks!")
+
+def reset_game():
+    # INTEGRATION: only reset the Debt Dilemma state; then rerun
+    for k in list(st.session_state.keys()):
+        # keep global app keys like 'user', 'current_page', 'current_game'
+        if k not in {"user", "current_page", "xp", "streak", "current_game", "temp_user"}:
+            del st.session_state[k]
+    init_state()
+    st.session_state.dd_start_ts = time.time()   # fresh timer after reset
+    st.rerun()
+
+def hospital_screen():
+    st.error("🏥 You've been hospitalized. Health hit 0%. Game over.")
+    #  use scoped button
+    st.buttondd("🔁 Play again", on_click=reset_game, key="btn_again_hospital", variant="success")
+
+def burnout_screen():
+    st.warning("😵 You burned out. Happiness hit 0%. Game over.")
+    #  use scoped button
+    st.buttondd("🔁 Play again", on_click=reset_game, key="btn_again_burnout", variant="success")
+
+def level_complete_screen():
+    _award_level_completion_if_needed()
+    st.success(f"🎉 Level {st.session_state.currentLevel} complete!")
+    def _go_next():
+        st.session_state.currentLevel += 1
+        lvl = get_level(st.session_state.currentLevel)
+        st.session_state.loan = LoanDetails(
+            principal=lvl.loanAmount,
+            interestRate=lvl.interestRate,
+            monthlyPayment=lvl.monthlyPayment,
+            totalOwed=float(lvl.loanAmount),
+            monthsPaid=0,
+            totalMonths=lvl.totalMonths,
+            missedPayments=0,
+            creditScore=st.session_state.loan.creditScore,
+        )
+        st.session_state.monthlyIncome = lvl.startingIncome
+        st.session_state.dd_start_ts = time.time()   # reset timer for new level
+        st.session_state.gamePhase = "setup"
+    st.buttondd("➡️ Start next level", on_click=_go_next, key="btn_next_level", variant="success")
+
+def completed_screen():
+    _award_level_completion_if_needed()
+    st.balloons()
+    st.success("🏁 You’ve finished all levels or ran out of rounds!")
+    #  use scoped button
+    st.buttondd("🔁 Play again", on_click=reset_game, key="btn_again_completed", variant="success")
+
+# ===============================
+# Public entry point expected by game.py
+# ===============================
+def show_debt_dilemma():
+    
+    load_css(os.path.join("assets", "styles.css"))
+    
+    _ensure_dd_css()
+    st.markdown(f'<div class="{DD_SCOPE_CLASS}">', unsafe_allow_html=True)  # OPEN SCOPE
+
+    # Initialize game state 
+    init_state()
+
+    # Route within the game
+    phase = st.session_state.gamePhase
+    if phase == "setup":
+        setup_screen()
+    elif phase == "hospital":
+        hospital_screen()
+    elif phase == "burnout":
+        burnout_screen()
+    elif phase == "level-complete":
+        level_complete_screen()
+    elif phase == "completed":
+        completed_screen()
+    else:
+        main_screen()
+
+    st.markdown('</div>', unsafe_allow_html=True)  # CLOSE SCOPE

phase/Student_view/games/profitpuzzle.py

@@ -0,0 +1,536 @@
+import os, time
+import streamlit as st
+from utils import api as backend         # HTTP to backend Space
+from utils import db as dbapi            # direct DB path (only if DISABLE_DB=0)
+
+DISABLE_DB = os.getenv("DISABLE_DB", "1") == "1"
+
+def _refresh_global_xp():
+    user = st.session_state.get("user")
+    if not user:
+        return
+    try:
+        if DISABLE_DB:
+            stats = backend.user_stats(user["user_id"])
+        else:
+            stats = dbapi.user_xp_and_level(user["user_id"])
+        st.session_state.xp = stats.get("xp", st.session_state.get("xp", 0))
+        st.session_state.streak = stats.get("streak", st.session_state.get("streak", 0))
+    except Exception as e:
+        st.warning(f"XP refresh failed: {e}")
+
+# --- CSS Styling ---
+def load_css():
+    st.markdown("""
+    <style>
+    /* Hide Streamlit default elements */
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    header {visibility: hidden;}
+    
+    /* Main container styling */
+    .main .block-container {
+        padding-top: 2rem;
+        padding-bottom: 2rem;
+        font-family: "Comic Sans MS", "Segoe UI", Arial, sans-serif;
+    }
+    
+    /* Game header styling */
+    .game-header {
+        background: linear-gradient(135deg, #d946ef, #ec4899);
+        padding: 2rem;
+        border-radius: 15px;
+        color: white;
+        text-align: center;
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+        margin-bottom: 2rem;
+    }
+    
+    /* Scenario card styling */
+    .scenario-card {
+        background: #ffffff;
+        padding: 2rem;
+        border-radius: 15px;
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+        border: 2px solid #e5e7eb;
+        margin-bottom: 1.5rem;
+    }
+    
+    /* Variables display */
+    .variables-card {
+        background: linear-gradient(to right, #4ade80, #22d3ee);
+        padding: 1.5rem;
+        border-radius: 12px;
+        color: white;
+        margin: 1rem 0;
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+    }
+    
+    /* Progress card */
+    .progress-card {
+        background: #3b82f6;
+        padding: 1.5rem;
+        border-radius: 12px;
+        color: white;
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+        margin-bottom: 1rem;
+    }
+    
+    /* XP display */
+    .xp-display {
+        background: #10b981;
+        padding: 1rem;
+        border-radius: 12px;
+        color: white;
+        text-align: center;
+        font-weight: bold;
+        margin-bottom: 1rem;
+    }
+    
+    /* Solution card */
+    .solution-card {
+        background: #f0f9ff;
+        padding: 1.5rem;
+        border-radius: 12px;
+        border: 2px solid #0ea5e9;
+        margin: 1rem 0;
+    }
+    
+    /* Custom button styling */
+    /* Default button styling (white buttons) */
+    .stButton > button {
+        background: #ffffff !important;
+        color: #111827 !important; /* dark gray text */
+        border: 2px solid #d1d5db !important;
+        border-radius: 12px !important;
+        padding: 0.75rem 1.5rem !important;
+        font-weight: bold !important;
+        font-size: 1.1rem !important;
+        transition: all 0.3s ease !important;
+        font-family: "Comic Sans MS", "Segoe UI", Arial, sans-serif !important;
+    }
+
+    .stButton > button:hover {
+        background: #f9fafb !important;
+        transform: translateY(-2px) !important;
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1) !important;
+    }
+
+    /* Next button styling */
+    .next-btn button {
+        background: #3b82f6 !important;
+        color: white !important;
+        border: none !important;
+    }
+    .next-btn button:hover {
+        background: #2563eb !important;
+    }
+
+    /* Restart button styling */
+    .restart-btn button {
+        background: #ec4899 !important;
+        color: white !important;
+        border: none !important;
+    }
+    .restart-btn button:hover {
+        background: #db2777 !important;
+    }
+
+    
+    
+    /* Text input styling */
+    .stTextInput > div > div > input {
+        border-radius: 12px !important;
+        border: 2px solid #d1d5db !important;
+        padding: 12px 16px !important;
+        font-size: 1.1rem !important;
+        font-family: "Comic Sans MS", "Segoe UI", Arial, sans-serif !important;
+    }
+    
+    .stTextInput > div > div > input:focus {
+        border-color: #10b981 !important;
+        box-shadow: 0 0 0 3px rgba(16, 185, 129, 0.2) !important;
+    }
+    
+    /* Slider styling */
+    .stSlider > div > div > div {
+        background: linear-gradient(to right, #4ade80, #22d3ee) !important;
+    }
+    
+    /* Sidebar styling */
+    .css-1d391kg {
+        background: #f8fafc;
+        border-radius: 12px;
+        padding: 1rem;
+    }
+    
+    /* Success/Error message styling */
+    .stSuccess {
+        background: #dcfce7 !important;
+        border: 2px solid #16a34a !important;
+        border-radius: 12px !important;
+        color: #15803d !important;
+    }
+    
+    .stError {
+        background: #fef2f2 !important;
+        border: 2px solid #dc2626 !important;
+        border-radius: 12px !important;
+        color: #dc2626 !important;
+    }
+    
+    .stInfo {
+        background: #eff6ff !important;
+        border: 2px solid #2563eb !important;
+        border-radius: 12px !important;
+        color: #1d4ed8 !important;
+    }
+    
+    .stWarning {
+        background: #fffbeb !important;
+        border: 2px solid #d97706 !important;
+        border-radius: 12px !important;
+        color: #92400e !important;
+    }
+    
+    /* Difficulty badge styling */
+    .difficulty-easy {
+        background: #dcfce7;
+        color: #16a34a;
+        padding: 0.25rem 0.75rem;
+        border-radius: 12px;
+        font-weight: bold;
+        font-size: 0.9rem;
+    }
+    
+    .difficulty-medium {
+        background: #fef3c7;
+        color: #d97706;
+        padding: 0.25rem 0.75rem;
+        border-radius: 12px;
+        font-weight: bold;
+        font-size: 0.9rem;
+    }
+    
+    .difficulty-hard {
+        background: #fecaca;
+        color: #dc2626;
+        padding: 0.25rem 0.75rem;
+        border-radius: 12px;
+        font-weight: bold;
+        font-size: 0.9rem;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+    
+#--- Show progress in sidebar ---
+# --- Sidebar Progress ---
+def show_profit_progress_sidebar():
+    scenarios = st.session_state.get("profit_scenarios", [])
+    total_scenarios = len(scenarios)
+    current_s = st.session_state.get("current_scenario", 0)
+    completed_count = len(st.session_state.get("completed_scenarios", []))
+
+    with st.sidebar:        
+        #add sidebar details for eg
+        st.sidebar.markdown(f"""
+        <div class="xp-display">
+            <h2>🏆 Your Progress</h2>
+            <p style="font-size: 1.5rem;">Total XP: {st.session_state.get("score", 0)}</p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.sidebar.markdown("### 🎯 Challenge List")
+        for i, s in enumerate(scenarios):
+            if i in st.session_state.completed_scenarios:
+                st.sidebar.success(f"✅ {s['title']}")
+            elif i == st.session_state.current_scenario:
+                st.sidebar.info(f"🎯 {s['title']} (Current)")
+            else:
+                st.sidebar.write(f"⭕ {s['title']}")
+
+        st.sidebar.markdown("""
+        <div style="background: #f0f9ff; padding: 1rem; border-radius: 12px; border: 2px solid #0ea5e9; margin-top: 1rem;">
+            <h3>🧮 Profit Formula</h3>
+            <p><strong>Profit = Revenue - Cost</strong></p>
+            <hr style="border-color: #0ea5e9;">
+            <p><strong>Revenue</strong> = Units × Selling Price</p>
+            <p><strong>Cost</strong> = Units × Cost per Unit</p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        #space and back button
+        st.sidebar.markdown("<br>", unsafe_allow_html=True)
+
+        if st.button("← Back to Games Hub", use_container_width=True):
+            st.session_state.current_game = None
+            st.rerun()
+
+def _current_scenario():
+    ps = st.session_state.get("profit_scenarios", [])
+    idx = st.session_state.get("current_scenario", 0)
+    return (ps[idx] if ps and 0 <= idx < len(ps) else None)
+
+
+def next_scenario():
+    total = len(st.session_state.get("profit_scenarios", []))
+    if st.session_state.get("current_scenario", 0) < total - 1:
+        st.session_state.current_scenario += 1
+        st.session_state.user_answer = ""
+        st.session_state.show_solution = False
+    st.rerun()
+
+def reset_game():
+    st.session_state.current_scenario = 0
+    st.session_state.user_answer = ""
+    st.session_state.show_solution = False
+    st.session_state.score = 0
+    st.session_state.completed_scenarios = []
+    st.session_state.pp_start_ts = time.time()
+    st.rerun()
+
+
+
+# --- Profit Puzzle Game ---
+def show_profit_puzzle():
+    # Load CSS styling
+    load_css()
+    
+    if "pp_start_ts" not in st.session_state:
+        st.session_state.pp_start_ts = time.time()
+
+    st.markdown("""
+    <div class="game-header">
+        <h1>🎯 Profit Puzzle Challenge!</h1>
+        <p>Learn to calculate profits while having fun! 🚀</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # -------------------------
+    # Game State Management
+    # -------------------------
+    if "current_scenario" not in st.session_state:
+        st.session_state.current_scenario = 0
+    if "user_answer" not in st.session_state:
+        st.session_state.user_answer = ""
+    if "show_solution" not in st.session_state:
+        st.session_state.show_solution = False
+    if "score" not in st.session_state:
+        st.session_state.score = 0
+    if "completed_scenarios" not in st.session_state:
+        st.session_state.completed_scenarios = []
+    if "slider_units" not in st.session_state:
+        st.session_state.slider_units = 10
+    if "slider_price" not in st.session_state:
+        st.session_state.slider_price = 50
+    if "slider_cost" not in st.session_state:
+        st.session_state.slider_cost = 30
+
+    # -------------------------
+    # Scenario Setup
+    # -------------------------
+    scenarios = [
+        {
+            "id": "juice-stand",
+            "title": "🧃 Juice Stand Profit",
+            "description": "You sold juice at your school event. Calculate your profit!",
+            "variables": {"units": 10, "sellingPrice": 50, "costPerUnit": 30},
+            "difficulty": "easy",
+            "xpReward": 20
+        },
+        {
+            "id": "craft-business",
+            "title": "🎨 Craft Business",
+            "description": "Your handmade crafts are selling well. What's your profit?",
+            "variables": {"units": 15, "sellingPrice": 80, "costPerUnit": 45},
+            "difficulty": "medium",
+            "xpReward": 20
+        },
+        {
+            "id": "bake-sale",
+            "title": "🧁 School Bake Sale",
+            "description": "You organized a bake sale fundraiser. Calculate the profit!",
+            "variables": {"units": 25, "sellingPrice": 60, "costPerUnit": 35},
+            "difficulty": "medium",
+            "xpReward": 20
+        },
+        {
+            "id": "tutoring-service",
+            "title": "📚 Tutoring Service",
+            "description": "You've been tutoring younger students. What's your profit after expenses?",
+            "variables": {"units": 8, "sellingPrice": 200, "costPerUnit": 50},
+            "difficulty": "hard",
+            "xpReward": 40
+        },
+        {
+            "id": "dynamic-scenario",
+            "title": "🎮 Custom Business Scenario",
+            "description": "Use the sliders to create your own business scenario and calculate profit!",
+            "variables": {"units": st.session_state.slider_units,
+                           "sellingPrice": st.session_state.slider_price,
+                           "costPerUnit": st.session_state.slider_cost},
+            "difficulty": "medium",
+            "xpReward": 50
+        }
+    ]
+
+    # after scenarios = [...]
+    st.session_state.profit_scenarios = scenarios  # Store scenarios in session state for sidebar access
+    scenario = scenarios[st.session_state.current_scenario]
+    is_dynamic = scenario["id"] == "dynamic-scenario"
+
+    # -------------------------
+    # Helper Functions
+    # -------------------------
+    def calculate_profit(units, price, cost):
+        return units * (price - cost)
+
+    def check_answer():
+        try:
+            user_val = float(st.session_state.user_answer)
+        except ValueError:
+            st.warning("Please enter a number.")
+            return
+
+        units = int(scenario["variables"]["units"])
+        price = int(scenario["variables"]["sellingPrice"])
+        cost  = int(scenario["variables"]["costPerUnit"])
+        actual_profit = units * (price - cost)
+
+        correct = abs(user_val - actual_profit) < 0.01
+        reward = int(scenario.get("xpReward", 20)) if correct else 0
+
+        # UI feedback
+        if correct:
+            st.success(f"✅ Awesome! You got it right! +{reward} XP 🎉")
+            st.session_state.score += reward
+            if st.session_state.current_scenario not in st.session_state.completed_scenarios:
+                st.session_state.completed_scenarios.append(st.session_state.current_scenario)
+        else:
+            st.error(f"❌ Oops. Correct profit is JA${actual_profit:.2f}")
+
+        # Persist to TiDB if logged in
+        user = st.session_state.get("user")
+        if user:
+            elapsed_ms = int((time.time() - st.session_state.get("pp_start_ts", time.time())) * 1000)
+
+            try:
+                if DISABLE_DB:
+                    # Route to backend Space
+                    backend.record_profit_puzzler_play(
+                        user_id=user["user_id"],
+                        puzzles_solved=1 if correct else 0,
+                        mistakes=0 if correct else 1,
+                        elapsed_ms=elapsed_ms,
+                        gained_xp=reward  # keep UI and server in sync
+                    )
+                else:
+                    # Direct DB path if you keep it
+                    if hasattr(dbapi, "record_profit_puzzler_play"):
+                        dbapi.record_profit_puzzler_play(
+                            user_id=user["user_id"],
+                            puzzles_solved=1 if correct else 0,
+                            mistakes=0 if correct else 1,
+                            elapsed_ms=elapsed_ms,
+                            gained_xp=reward
+                        )
+                    else:
+                        # Fallback to your existing detailed writer
+                        dbapi.record_profit_puzzle_result(
+                            user_id=user["user_id"],
+                            scenario_id=scenario.get("id") or f"scenario_{st.session_state.current_scenario}",
+                            title=scenario.get("title", f"Scenario {st.session_state.current_scenario+1}"),
+                            units=int(scenario["variables"]["units"]),
+                            price=int(scenario["variables"]["sellingPrice"]),
+                            cost=int(scenario["variables"]["costPerUnit"]),
+                            user_answer=float(st.session_state.user_answer),
+                            actual_profit=float(actual_profit),
+                            is_correct=bool(correct),
+                            gained_xp=int(reward)
+                        )
+
+                _refresh_global_xp()
+            except Exception as e:
+                st.warning(f"Save failed: {e}")
+        else:
+            st.info("Login to earn and save XP.")
+
+        st.session_state.show_solution = True
+
+    def next_scenario():
+        if st.session_state.get("current_scenario", 0) < len(st.session_state.get("profit_scenarios", [])) - 1:
+            st.session_state.current_scenario += 1
+            st.session_state.user_answer = ""
+            st.session_state.show_solution = False
+            st.session_state.pp_start_ts = time.time()
+        st.rerun()
+
+    def reset_game():
+        st.session_state.current_scenario = 0
+        st.session_state.user_answer = ""
+        st.session_state.show_solution = False
+        st.session_state.score = 0
+        st.session_state.completed_scenarios = []
+
+    # -------------------------
+    # UI Layout
+    # -------------------------
+    
+    difficulty_class = f"difficulty-{scenario['difficulty']}"
+    st.markdown(f"""
+    <div class="scenario-card">
+        <h2>{scenario['title']}</h2>
+        <span class="{difficulty_class}">{scenario['difficulty'].upper()}</span>
+        <p style="margin-top: 1rem; font-size: 1.1rem;">{scenario["description"]}</p>
+        <h3>📊 Business Details</h3>
+        <p><strong>Units Sold:</strong> {scenario['variables']['units']}</p>
+        <p><strong>Selling Price per Unit:</strong> JA${scenario['variables']['sellingPrice']}</p>
+        <p><strong>Cost per Unit:</strong> JA${scenario['variables']['costPerUnit']}</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+    if is_dynamic:
+        st.markdown("### 🎛️ Customize Your Business")
+        st.session_state.slider_units = st.slider("Units Sold", 1, 50, st.session_state.slider_units)
+        st.session_state.slider_price = st.slider("Selling Price per Unit (JA$)", 10, 200, st.session_state.slider_price, 5)
+        st.session_state.slider_cost = st.slider("Cost per Unit (JA$)", 5, st.session_state.slider_price - 1, st.session_state.slider_cost, 5)
+
+        scenario["variables"] = {
+            "units": st.session_state.slider_units,
+            "sellingPrice": st.session_state.slider_price,
+            "costPerUnit": st.session_state.slider_cost
+        }
+
+
+    st.markdown("### 💰 What's the profit?")
+    st.text_input("Enter Profit (JA$):", key="user_answer", disabled=st.session_state.show_solution, placeholder="Type your answer here...")
+
+    if not st.session_state.show_solution:
+        st.button("🎯 Check My Answer!", on_click=check_answer)
+    else:
+        actual_profit = calculate_profit(
+            scenario["variables"]["units"],
+            scenario["variables"]["sellingPrice"],
+            scenario["variables"]["costPerUnit"]
+        )
+
+        st.markdown(f"""
+        <div class="solution-card">
+            <h3>🧮 Solution Breakdown</h3>
+            <p><strong>Revenue:</strong> {scenario['variables']['units']} × JA${scenario['variables']['sellingPrice']} = JA${scenario['variables']['units'] * scenario['variables']['sellingPrice']}</p>
+            <p><strong>Total Cost:</strong> {scenario['variables']['units']} × JA${scenario['variables']['costPerUnit']} = JA${scenario['variables']['units'] * scenario['variables']['costPerUnit']}</p>
+            <p><strong>Profit:</strong> JA${scenario['variables']['units'] * scenario['variables']['sellingPrice']} - JA${scenario['variables']['units'] * scenario['variables']['costPerUnit']} = <span style="color: #10b981; font-weight: bold; font-size: 1.2rem;">JA${actual_profit}</span></p>
+        </div>
+        """, unsafe_allow_html=True)
+
+        next_col, restart_col = st.columns(2)
+        with next_col:
+            if st.session_state.current_scenario < len(scenarios) - 1:
+                st.markdown('<div class="next-btn">', unsafe_allow_html=True)
+                st.button("➡️ Next Challenge", on_click=next_scenario)
+                st.markdown('</div>', unsafe_allow_html=True)
+        with restart_col:
+            st.markdown('<div class="restart-btn">', unsafe_allow_html=True)
+            st.button("🔄 Start Over", on_click=reset_game)
+            st.markdown('</div>', unsafe_allow_html=True)
+

phase/Student_view/lesson.py

@@ -0,0 +1,649 @@
+import streamlit as st
+from typing import List, Dict, Any, Optional, Tuple
+import re
+import datetime  # NEW
+
+# Internal API client (already used across the app)
+# Uses BACKEND_URL/BACKEND_TOKEN env vars and has retry logic
+# See utils/api.py for details
+from utils import api as backend_api
+
+
+FALLBACK_TAG = "<!--fallback-->"
+
+
+# ---------------------------------------------
+# Page state helpers
+# ---------------------------------------------
+_SS_DEFAULTS = {
+    "level": "beginner",              # beginner | intermediate | advanced
+    "module_id": None,                 # int (1-based)
+    "topic_idx": 0,                    # 0-based within module
+    "mode": "catalog",                # catalog | lesson | quiz | results
+    "topics_cache": {},                # {(level, module_id): [(title, text), ...]}
+    "quiz_data": None,                 # original quiz payload (list[dict])
+    "quiz_answers": {},                # q_index -> "A"|"B"|"C"|"D"
+    "quiz_result": None,               # backend result dict
+    "chatbot_feedback": None,          # str
+}
+
+
+def _ensure_state():
+    for k, v in _SS_DEFAULTS.items():
+        if k not in st.session_state:
+            st.session_state[k] = v
+
+
+# ---------------------------------------------
+# Content metadata (UI only)
+# ---------------------------------------------
+# These titles mirror the React version you shared, so the experience feels the same.
+MODULES_META: Dict[str, List[Dict[str, Any]]] = {
+    "beginner": [
+        {
+            "id": 1,
+            "title": "Understanding Money",
+            "description": "Learn the basics of what money is, its uses, and how to manage it.",
+            "duration": "20 min",
+            "completed": False,
+            "locked": False,
+            "difficulty": "Easy",
+            "topics": [
+                "What is Money?",
+                "Needs vs. Wants",
+                "Earning Money",
+                "Saving Money",
+                "Spending Wisely",
+                "Play: Money Match",
+                "Quiz",
+                "Summary: My Money Plan"
+            ]
+        },
+        {
+            "id": 2,
+            "title": "Basic Budgeting",
+            "description": "Start building the habit of planning and managing money through budgeting.",
+            "duration": "20 min",
+            "completed": False,
+            "locked": False,
+            "difficulty": "Easy",
+            "topics": [
+                "What is a Budget?",
+                "Income and Expenses",
+                "Profit and Loss",
+                "Saving Goals",
+                "Making Choices",
+                "Play: Budget Builder",
+                "Quiz",
+                "Summary: My First Budget"
+            ]
+        },
+        {
+            "id": 3,
+            "title": "Money in Action",
+            "description": "Learn how money is used in everyday transactions and its role in society.",
+            "duration": "20 min",
+            "completed": False,
+            "locked": False,
+            "difficulty": "Easy",
+            "topics": [
+                "Paying for Things",
+                "Keeping Track of Money",
+                "What Are Taxes?",
+                "Giving and Sharing",
+                "Money Safety",
+                "Play: Piggy Bank Challenge",
+                "Quiz",
+                "Summary: Money Journal"
+            ]
+        },
+        {
+            "id": 4,
+            "title": "Simple Business Ideas",
+            "description": "Explore the basics of starting a small business and earning profit.",
+            "duration": "20 min",
+            "completed": False,
+            "locked": False,
+            "difficulty": "Easy",
+            "topics": [
+                "What is a Business?",
+                "Costs in a Business",
+                "Revenue in a Business",
+                "Profit in a Business",
+                "Advertising Basics",
+                "Play: Smart Shopper",
+                "Quiz",
+                "Summary: My Business Plan"
+            ]
+        }
+    ],
+    "intermediate": [],
+    "advanced": [],
+}
+
+
+# Helper to read topic titles regardless of whether metadata uses `topics` or `topic_labels`
+
+def _topic_plan(level: str, module_id: int):
+    """
+    Returns a list of (title, backend_ordinal) after filtering:
+    - drop any 'Play:' topic
+    - drop 'Quiz'
+    - keep first five + the Summary (6 total)
+    backend_ordinal is the 1-based index in the original metadata (so backend files line up).
+    """
+    mod = next(m for m in MODULES_META[level] if m["id"] == module_id)
+    raw = (mod.get("topics") or mod.get("topic_labels") or [])
+    plan = []
+    for i, t in enumerate(raw, start=1):
+        tl = t.strip().lower()
+        if tl == "quiz" or tl.startswith("play:"):
+            continue
+        plan.append((t, i))
+
+    # Ensure at most 6 topics: first five + Summary if present
+    if len(plan) > 6:
+        # Prefer keeping a 'Summary' entry last if it exists
+        summary_pos = next((idx for idx, (title, _) in enumerate(plan)
+                            if title.strip().lower().startswith("summary")), None)
+        if summary_pos is not None:
+            plan = plan[:5] + [plan[summary_pos]]
+        else:
+            plan = plan[:6]
+    return plan
+
+def _topic_titles(level: str, module_id: int):
+    return [t for (t, _) in _topic_plan(level, module_id)]
+
+
+# ---------------------------------------------
+# Backend integrations
+# ---------------------------------------------
+@st.cache_data(show_spinner=False, ttl=300)
+def _fetch_topic_from_backend(level: str, module_id: int, topic_idx: int) -> Tuple[str, str]:
+    """
+    Returns (ui_title, content). Tries backend first, never crashes the UI.
+    Backend expects folders like: /app/lessons/lesson_{module_id}/topic_{ordinal}.txt
+    """
+    plan = _topic_plan(level, module_id)
+    ui_title, backend_ordinal = plan[topic_idx]  # 1-based in original list
+
+    payload = {
+        "lesson": f"lesson_{module_id}",  # folder name
+        "module": str(module_id),         # kept for compatibility
+        "topic": str(backend_ordinal),    # 1-based ordinal mapping
+    }
+
+    data = {}
+    try:
+        # Try your documented route, then a simpler alias
+        data = backend_api._try_candidates(
+            "POST",
+            [
+                ("/agents/lesson", {"json": payload}),
+                ("/lesson",        {"json": payload}),
+            ],
+        ) or {}
+    except Exception as e:
+        # Log once, keep the UI moving
+        st.warning(f"Lesson fetch failed for lesson_{module_id}/topic_{backend_ordinal}: {e}")
+        data = {}
+
+    # Accept several possible shapes
+    content = ""
+    for k in ("lesson_content", "content", "text", "body"):
+        v = data.get(k)
+        if isinstance(v, str) and v.strip():
+            content = v.strip()
+            break
+        if isinstance(v, dict):
+            vv = v.get("content") or v.get("text") or v.get("body")
+            if isinstance(vv, str) and vv.strip():
+                content = vv.strip()
+                break
+
+    return ui_title, content
+
+
+def _extract_takeaways(text: str, max_items: int = 5) -> List[str]:
+    """Heuristic key-takeaway extractor from raw lesson text."""
+    if not text:
+        return []
+
+    # Prefer explicit sections
+    m = re.search(r"(?mi)^\s*(Key\s*Takeaways?|Summary)\s*[:\n]+(.*)$", text, re.DOTALL)
+    if m:
+        body = m.group(2)
+        lines = [ln.strip(" •-*–\t") for ln in body.splitlines() if ln.strip()]
+        items = [ln for ln in lines if len(ln) > 3][:max_items]
+        if items:
+            return items
+
+    # Otherwise, harvest bullet-y looking lines
+    bullets = [
+        ln.strip(" •-*–\t")
+        for ln in text.splitlines()
+        if ln.strip().startswith(("-", "•", "*", "–")) and len(ln.strip()) > 3
+    ]
+    if bullets:
+        return bullets[:max_items]
+
+    # Fallback: first few sentences
+    sents = re.split(r"(?<=[.!?])\s+", text.strip())
+    return [s for s in sents if len(s) > 20][:min(max_items, 3)]
+
+
+def _start_quiz(level: str, module_id: int) -> Optional[List[Dict[str, Any]]]:
+    """Ask backend to generate a 5-question mini quiz for this module."""
+    module_conf = next(m for m in MODULES_META[level] if m["id"] == module_id)
+    try:
+        quiz = backend_api.generate_quiz(
+            lesson_id=module_id,            # int id works; backend uses it for retrieval bucketing
+            level_slug=level,               # "beginner" | "intermediate" | "advanced"
+            lesson_title=module_conf["title"],
+        )
+        if isinstance(quiz, list) and quiz:
+            return quiz
+        return None
+    except Exception as e:
+        st.error(f"Could not generate quiz: {e}")
+        return None
+
+
+def _submit_quiz(level: str, module_id: int, original_quiz: List[Dict[str, Any]], answers_map: Dict[int, str]) -> Optional[Dict[str, Any]]:
+    """Submit answers and get score + tutor feedback."""
+    user_answers = []
+    for i, q in enumerate(original_quiz):
+        # Expect letters A-D; default to ""
+        user_answers.append({
+            "question": q.get("question", f"Q{i+1}"),
+            "answer": answers_map.get(i, ""),
+        })
+    try:
+        result = backend_api.submit_quiz(
+            lesson_id=module_id,
+            level_slug=level,
+            user_answers=user_answers,
+            original_quiz=original_quiz,
+        )
+        return result
+    except Exception as e:
+        st.error(f"Could not submit quiz: {e}")
+        return None
+
+def _send_quiz_summary_to_chatbot(result: Dict[str, Any]):
+    """
+    Send a concise, actionable summary of the quiz outcome to the chatbot,
+    then navigate to the Chatbot page with the conversation pre-seeded.
+    """
+    level = st.session_state.level
+    module_id = st.session_state.module_id
+    mod = next(m for m in MODULES_META[level] if m["id"] == module_id)
+
+    score = result.get("score", {})
+    correct = int(score.get("correct", 0))
+    total = int(score.get("total", 0))
+    feedback = (result.get("feedback") or st.session_state.get("chatbot_feedback") or "").strip()
+
+    user_prompt = (
+        f"I just finished the quiz for '{mod['title']}' (module {module_id}) "
+        f"and scored {correct}/{total}. Please give me 2–3 targeted tips and 1 tiny action "
+        f"to improve before the next lesson. If there were wrong answers, explain them simply.\n\n"
+        f"Context from grader:\n{feedback}"
+    )
+
+    try:
+        # Hit your FastAPI chatbot route (HF under the hood)
+        resp = backend_api.send_to_chatbot([
+            {"role": "system", "content": "You are a friendly financial tutor for Jamaican students."},
+            {"role": "user", "content": user_prompt}
+        ])
+        bot_reply = (resp or {}).get("reply", "").strip()
+    except Exception as e:
+        bot_reply = f"(Chatbot unavailable) Based on your result: {feedback or 'Nice work!'}"
+
+    # Seed the Chatbot page's message list so the conversation is visible immediately
+    msgs = st.session_state.get("messages") or [{
+        "id": "1",
+        "text": "Hi! I'm your AI Financial Tutor. What would you like to learn today?",
+        "sender": "assistant",
+        "timestamp": datetime.datetime.now(),
+    }]
+    msgs.append({"text": user_prompt, "sender": "user", "timestamp": datetime.datetime.now()})
+    msgs.append({"text": bot_reply,   "sender": "assistant", "timestamp": datetime.datetime.now()})
+    st.session_state.messages = msgs
+
+    # Jump straight to Chatbot page
+    st.session_state.current_page = "Chatbot"
+
+def _fallback_text(title: str, module_id: int, topic_ordinal: int) -> str:
+    """
+    Minimal on-brand copy if the backend has not supplied a topic file yet.
+    Tailored to beginner modules so the UI stays useful.
+    """
+    t = title.strip().lower()
+    if "what is money" in t or "money" == t:
+        return ("Money is a tool we use to trade for goods and services. "
+                "In Jamaica we use JMD coins and notes, and many people also pay digitally. "
+                "You can spend, save, or share money, but it is limited, so plan how you use it.") + "\n" + FALLBACK_TAG
+    if "need" in t and "want" in t:
+        return ("Needs keep you safe and healthy, like food, clothes, and school supplies. "
+                "Wants are nice to have, like toys or snacks. Cover needs first, then plan for wants.") + "\n" + FALLBACK_TAG
+    if "earn" in t:
+        return ("You earn money by doing work or providing value. Small jobs add up. "
+                "Earnings give you choices to spend, save, or share, and teach the value of effort.") + "\n" + FALLBACK_TAG
+    if "sav" in t:
+        return ("Saving means putting aside some money now for future needs or goals. "
+                "Start small and be consistent. A jar, a partner plan, or a bank account all help.") + "\n" + FALLBACK_TAG
+    if "spend" in t or "wisely" in t:
+        return ("Spending wisely means comparing prices, making a simple budget, and avoiding impulse buys. "
+                "Aim for best value so your goals stay on track.") + "\n" + FALLBACK_TAG
+    if "summary" in t or "journal" in t or "plan" in t:
+        return ("Quick recap: cover needs first, set a small saving goal, and make one spending rule for the week. "
+                "Write one action you will try before the next lesson.") + "\n" + FALLBACK_TAG
+    if "quiz" in t:
+        return ("Take a short quiz to check your understanding of this lesson.") + "\n" + FALLBACK_TAG
+    # Generic fallback
+    return (f"This unit will be populated from lesson_{module_id}/topic_{topic_ordinal}.txt. "
+            "For now, review the key idea and write one example from daily life.") + "\n" + FALLBACK_TAG
+
+
+# ---------------------------------------------
+# UI building blocks
+# ---------------------------------------------
+def _render_catalog():
+    st.header("Financial Education")
+    st.caption("Build your financial knowledge with structured paths for every skill level.")
+
+    level = st.session_state.get("level", _SS_DEFAULTS["level"])
+
+    cols = st.columns(3)
+    for i, mod in enumerate(MODULES_META[level]):
+        with cols[i % 3]:
+            st.subheader(mod["title"])
+            if mod.get("description"):
+                st.caption(mod["description"])
+            st.caption(f"Duration: {mod.get('duration','—')} · Difficulty: {mod.get('difficulty','—')}")
+            with st.expander("Topics include"):
+                for t, _ord in _topic_plan(level, mod["id"]):
+                    st.write("• ", t)
+            if st.button("Start Learning", key=f"start_{level}_{mod['id']}"):
+                # nuke stale topic cache for this module and any cached fetch failures
+                st.session_state.topics_cache.pop((level, mod["id"]), None)
+                try:
+                    st.cache_data.clear()
+                except Exception:
+                    pass
+
+                st.session_state.module_id = mod["id"]
+                st.session_state.topic_idx = 0
+                st.session_state.mode = "lesson"
+                st.rerun()
+
+
+
+def _render_lesson():
+    level = st.session_state.level
+    module_id = st.session_state.module_id
+    if module_id is None:
+        st.session_state.mode = "catalog"
+        st.rerun()
+
+    mod = next(m for m in MODULES_META[level] if m["id"] == module_id)
+
+    st.markdown(f"### {mod['title']}")
+    if mod.get("description"):
+        st.caption(mod["description"])
+
+    topics = _get_topics(level, module_id)
+
+    if not topics:
+        # build topics from metadata and use fallbacks so the page is never blank
+        plan = _topic_plan(level, module_id)
+        topics = [(title, _fallback_text(title, module_id, i + 1)) for i, (title, _) in enumerate(plan)]
+        st.session_state.topics_cache[(level, module_id)] = topics
+
+    with st.container(border=True):
+        progress = (st.session_state.topic_idx + 1) / max(1, len(topics))
+        st.progress(progress, text=f"Unit {st.session_state.topic_idx + 1} of {len(topics)}")
+
+    t_title, t_text = topics[st.session_state.topic_idx]
+
+    # Special Quiz placeholder
+    if t_title.strip().lower() == "quiz":
+        with st.spinner("Generating quiz…"):
+            quiz = _start_quiz(level, module_id)
+        if quiz:
+            st.session_state.quiz_data = quiz
+            st.session_state.quiz_answers = {}
+            st.session_state.mode = "quiz"
+            st.rerun()
+        else:
+            st.error("Quiz could not be generated. Please try again or skip.")
+        return
+
+    st.subheader(t_title)
+    source_note = "Default" if FALLBACK_TAG in t_text else "Backend"
+    st.caption(f"Source: {source_note}")
+    if t_text:
+        # strip the marker and render HTML from backend files (e.g., <b>Money</b>)
+        cleaned = t_text.replace(FALLBACK_TAG, "")
+        st.markdown(cleaned, unsafe_allow_html=True)
+
+        takeaways = _extract_takeaways(cleaned)
+        if takeaways:
+            st.markdown("#### Key Takeaways")
+            for it in takeaways:
+                st.write("✅ ", it)
+    else:
+        st.info("Content coming soon.")
+
+    col1, col2, col3 = st.columns([1, 1, 1])
+    with col1:
+        if st.button("← Previous", disabled=st.session_state.topic_idx == 0):
+            st.session_state.topic_idx -= 1
+            st.rerun()
+    with col2:
+        if st.button("Back to Modules"):
+            st.session_state.mode = "catalog"
+            st.session_state.module_id = None
+            st.rerun()
+    with col3:
+        is_last = st.session_state.topic_idx >= len(topics) - 1
+
+        if is_last:
+            # NEW: auto-start quiz when learner reaches the last topic
+            if not st.session_state.get("_auto_quiz_started", False):
+                st.session_state["_auto_quiz_started"] = True
+                with st.spinner("Generating quiz…"):
+                    quiz = _start_quiz(level, module_id)
+                if quiz:
+                    st.session_state.quiz_data = quiz
+                    st.session_state.quiz_answers = {}
+                    st.session_state.mode = "quiz"
+                    st.rerun()
+                else:
+                    st.error("Quiz could not be generated. Please try again.")
+            else:
+                # Fallback button if auto-start once failed
+                if st.button("Take Lesson Quiz →"):
+                    with st.spinner("Generating quiz…"):
+                        quiz = _start_quiz(level, module_id)
+                    if quiz:
+                        st.session_state.quiz_data = quiz
+                        st.session_state.quiz_answers = {}
+                        st.session_state.mode = "quiz"
+                        st.rerun()
+                    else:
+                        st.error("Quiz could not be generated. Please try again.")
+        else:
+            if st.button("Next →"):
+                st.session_state.topic_idx += 1
+                st.rerun()
+
+
+    with st.expander("Module Units", expanded=False):
+        for i, (tt, _) in enumerate(topics):
+            label = f"{i+1}. {tt}"
+            st.button(label, key=f"jump_{i}", on_click=lambda j=i: st.session_state.update({"topic_idx": j}) or st.rerun())
+
+def _get_topics(level: str, module_id: int) -> List[Tuple[str, str]]:
+    """
+    Build the six-topic plan from metadata titles, try backend for each,
+    and if content is missing, provide a short fallback paragraph.
+    """
+    cache_key = (level, module_id)
+    if cache_key in st.session_state.topics_cache:
+        return st.session_state.topics_cache[cache_key]
+
+    plan = _topic_plan(level, module_id)   # six titles max
+    out: List[Tuple[str, str]] = []
+
+    for idx in range(len(plan)):
+        title, content = _fetch_topic_from_backend(level, module_id, idx)
+        if not content:
+            content = _fallback_text(title, module_id, idx + 1)
+        out.append((title, content))
+
+    st.session_state.topics_cache[cache_key] = out
+    return out
+
+def _letter_for(i: int) -> str:
+    return chr(ord("A") + i)
+
+
+def _render_quiz():
+    quiz: List[Dict[str, Any]] = st.session_state.quiz_data or []
+    if not quiz:
+        st.session_state.mode = "lesson"
+        st.rerun()
+
+    st.markdown("### Lesson Quiz")
+
+    # Render each question as a block (single page quiz)
+    for q_idx, q in enumerate(quiz):
+        st.markdown(f"**Q{q_idx+1}. {q.get('question','').strip()}**")
+        opts = q.get("options") or []
+        # Build labels like "A. option"
+        labels = [f"{_letter_for(i)}. {opt}" for i, opt in enumerate(opts)]
+
+        def _on_select():
+            sel = st.session_state[f"ans_{q_idx}"]  # "A. option text"
+            letter = sel.split(".", 1)[0] if isinstance(sel, str) else ""
+            st.session_state.quiz_answers[q_idx] = letter  # store "A".."D"
+
+        # Preselect previously chosen letter, if any
+        saved_letter = st.session_state.quiz_answers.get(q_idx)  # "A"
+        pre_idx = next((i for i, l in enumerate(labels) if saved_letter and l.startswith(f"{saved_letter}.")), None)
+
+        st.radio(
+            "",
+            labels,
+            index=pre_idx,  # None means no default
+            key=f"ans_{q_idx}",
+            on_change=_on_select,
+        )
+        st.divider()
+
+        # Submit
+    all_answered = len(st.session_state.quiz_answers) == len(quiz)
+    if st.button("Submit Quiz", disabled=not all_answered):
+        with st.spinner("Grading…"):
+            result = _submit_quiz(
+                st.session_state.level,
+                st.session_state.module_id,
+                quiz,
+                st.session_state.quiz_answers,
+            )
+        if result:
+            st.session_state.quiz_result = result
+            st.session_state.chatbot_feedback = result.get("feedback")
+            # NEW: immediately send to chatbot and navigate there
+            _send_quiz_summary_to_chatbot(result)
+            st.rerun()
+
+
+
+def _render_results():
+    result = st.session_state.quiz_result or {}
+    score = result.get("score", {})
+    correct = score.get("correct", 0)
+    total = score.get("total", 0)
+
+    st.success(f"Quiz Complete! You scored {correct} / {total}.")
+
+    wrong = result.get("wrong", [])
+    if wrong:
+        with st.expander("Review your answers"):
+            for w in wrong:
+                st.markdown(f"**{w.get('question','')}**")
+                st.write(f"Your answer: {w.get('your_answer','')}")
+                st.write(f"Correct answer: {w.get('correct_answer','')}")
+                st.divider()
+
+    fb = st.session_state.chatbot_feedback
+    if fb:
+        st.markdown("#### Tutor Explanation")
+        st.write(fb)
+
+    level = st.session_state.level
+    module_id = st.session_state.module_id
+    planned = next((m.get("topics", []) for m in MODULES_META[level] if m["id"] == module_id), [])
+    try:
+        quiz_index = [t.strip().lower() for t in planned].index("quiz")
+    except ValueError:
+        quiz_index = None
+
+    c1, c2, c3 = st.columns([1, 1, 1])
+    with c1:
+        if st.button("Back to Modules"):
+            st.session_state.mode = "catalog"
+            st.session_state.module_id = None
+            st.rerun()
+    with c2:
+        if st.button("Ask the Chatbot →"):
+            st.session_state.current_page = "Chatbot"
+            st.session_state.chatbot_prefill = fb
+            st.rerun()
+    with c3:
+        if quiz_index is not None and quiz_index + 1 < len(planned):
+            if st.button("Continue Lesson →"):
+                st.session_state.mode = "lesson"
+                st.session_state.topic_idx = quiz_index + 1
+                st.rerun()
+
+
+# ---------------------------------------------
+# Public entry point(s)
+# ---------------------------------------------
+
+def render():
+    _ensure_state()
+
+    # Breadcrumb
+    st.caption("Learning Path · " + st.session_state.level.capitalize())
+
+    mode = st.session_state.mode
+    if mode == "catalog":
+        _render_catalog()
+    elif mode == "lesson":
+        _render_lesson()
+    elif mode == "quiz":
+        _render_quiz()
+    elif mode == "results":
+        _render_results()
+    else:
+        st.session_state.mode = "catalog"
+        _render_catalog()
+
+
+# Some parts of the app import pages and call a conventional `show()`
+show_page = render
+
+
+if __name__ == "__main__":
+    # Allow standalone run for local testing
+    st.set_page_config(page_title="Lesson", page_icon="📘", layout="centered")
+    render()
+
+#comment

phase/Student_view/practice_quiz.py

@@ -0,0 +1 @@
+#added a practice_quiz.py (for the general practice quiz code could go here and the lesson_quiz code stuff in quiz.py)

phase/Student_view/quiz.py

@@ -0,0 +1,413 @@
+import os
+import streamlit as st
+from utils.quizdata import quizzes_data
+import datetime
+import json
+from utils import db as dbapi
+import utils.api as api
+
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
+
+def _get_quiz_from_source(quiz_id: int):
+    """
+    Fetch a quiz payload from the local DB (if enabled) or from the backend API.
+    Expected backend shape: {'quiz': {...}, 'items': [...]}
+    """
+    if USE_LOCAL_DB and hasattr(dbapi, "get_quiz"):
+        return dbapi.get_quiz(quiz_id)
+    # backend: expose GET /quizzes/{quiz_id}
+    return api.get_quiz(quiz_id)
+
+def _submit_quiz_result(student_id: int, assignment_id: int, quiz_id: int,
+                        score: int, total: int, details: dict):
+    """
+    Submit a quiz result either to the local DB or to the backend API.
+    """
+    if USE_LOCAL_DB and hasattr(dbapi, "submit_quiz"):
+        return dbapi.submit_quiz(student_id=student_id,
+                                 assignment_id=assignment_id,
+                                 quiz_id=quiz_id,
+                                 score=score, total=total, details=details)
+    # backend: POST /quizzes/submit (or your route of choice)
+    # utils.api should wrap that route; below assumes api.submit_quiz exists.
+    return api.submit_quiz(student_id=student_id,
+                           assignment_id=assignment_id,
+                           quiz_id=quiz_id,
+                           score=score, total=total, details=details)
+
+def _load_quiz_obj(quiz_id):
+    """
+    Return a normalized quiz object from either quizzes_data (built-in)
+    or the backend/DB. Normalized shape:
+      {"title": str, "questions": [{"question","options","answer","points"}...]}
+    """
+    # Built-ins first
+    if quiz_id in quizzes_data:
+        q = quizzes_data[quiz_id]
+        for qq in q.get("questions", []):
+            qq.setdefault("points", 1)
+        return q
+
+    # Teacher-assigned (DB/backend)
+    data = _get_quiz_from_source(int(quiz_id))  # <-- uses API when DISABLE_DB=1
+    if not data:
+        return {"title": f"Quiz {quiz_id}", "questions": []}
+
+    items_out = []
+    for it in (data.get("items") or []):
+        opts = it.get("options")
+        if isinstance(opts, (str, bytes)):
+            try:
+                opts = json.loads(opts)
+            except Exception:
+                opts = []
+        opts = opts or []
+
+        ans = it.get("answer_key")
+        if isinstance(ans, (str, bytes)):
+            try:
+                ans = json.loads(ans)  # support '["A","C"]'
+            except Exception:
+                pass  # allow "A"
+
+        def letter_to_text(letter):
+            if isinstance(letter, str):
+                idx = ord(letter.upper()) - 65
+                return opts[idx] if 0 <= idx < len(opts) else letter
+            return letter
+
+        if isinstance(ans, list):
+            ans_text = [letter_to_text(a) for a in ans]
+        else:
+            ans_text = letter_to_text(ans)
+
+        items_out.append({
+            "question": it.get("question", ""),
+            "options":  opts,
+            "answer":   ans_text,                 # text or list of texts
+            "points":   int(it.get("points", 1)),
+        })
+
+    title = (data.get("quiz") or {}).get("title", f"Quiz {quiz_id}")
+    return {"title": title, "questions": items_out}
+
+def _letter_to_index(ch: str) -> int:
+    return ord(ch.upper()) - 65  # 'A'->0, 'B'->1, ...
+
+def _correct_to_indices(correct, options: list[str]):
+    """
+    Map 'correct' (letters like 'A' or ['A','C'] OR option text(s)) -> list of indices.
+    """
+    idxs = []
+    if isinstance(correct, list):
+        for c in correct:
+            if isinstance(c, str):
+                if len(c) == 1 and c.isalpha():
+                    idxs.append(_letter_to_index(c))
+                elif c in options:
+                    idxs.append(options.index(c))
+    elif isinstance(correct, str):
+        if len(correct) == 1 and correct.isalpha():
+            idxs.append(_letter_to_index(correct))
+        elif correct in options:
+            idxs.append(options.index(correct))
+    # keep only valid unique indices
+    return sorted({i for i in idxs if 0 <= i < len(options)})
+
+def _normalize_user_to_indices(user_answer, options: list[str]):
+    """
+    user_answer can be option text (or list of texts), or letters; return indices.
+    """
+    idxs = []
+    if isinstance(user_answer, list):
+        for a in user_answer:
+            if isinstance(a, str):
+                if a in options:
+                    idxs.append(options.index(a))
+                elif len(a) == 1 and a.isalpha():
+                    idxs.append(_letter_to_index(a))
+    elif isinstance(user_answer, str):
+        if user_answer in options:
+            idxs.append(options.index(user_answer))
+        elif len(user_answer) == 1 and user_answer.isalpha():
+            idxs.append(_letter_to_index(user_answer))
+    return sorted([i for i in idxs if 0 <= i < len(options)])
+
+# --- Helper for level styling ---
+def get_level_style(level):
+    if level.lower() == "beginner":
+        return ("#28a745", "Beginner")  # Green
+    elif level.lower() == "intermediate":
+        return ("#ffc107", "Intermediate")  # Yellow
+    elif level.lower() == "advanced":
+        return ("#dc3545", "Advanced")  # Red
+    else:
+        return ("#6c757d", level)
+
+
+# --- Sidebar Progress ---
+def show_quiz_progress_sidebar(quiz_id):
+    qobj = _load_quiz_obj(quiz_id)
+    total_q = max(1, len(qobj.get("questions", [])))
+    current_q = int(st.session_state.get("current_q", 0))
+    answered_count = len(st.session_state.get("answers", {}))
+
+    with st.sidebar:
+        st.markdown("""
+        <div style="display: flex; align-items: center; justify-content: space-between; margin-bottom: 20px;">
+            <h3 style="margin: 0; color: #333;">Quiz Progress</h3>
+            <div style="font-size: 18px;">☰</div>
+        </div>
+        """, unsafe_allow_html=True)
+
+        st.markdown(f"""
+        <div style="margin-bottom: 15px;">
+            <strong style="color: #333; font-size: 14px;">{qobj.get('title','Quiz')}</strong>
+        </div>
+        """, unsafe_allow_html=True)
+
+        progress_value = (current_q) / total_q if current_q < total_q else 1.0
+        st.progress(progress_value)
+
+        st.markdown(f"""
+        <div style="text-align: center; margin: 10px 0; font-weight: bold; color: #333;">
+            {min(current_q + 1, total_q)} of {total_q}
+        </div>
+        """, unsafe_allow_html=True)
+
+        cols = st.columns(5)
+        for i in range(total_q):
+            col = cols[i % 5]
+            with col:
+                if i == current_q and current_q < total_q:
+                    st.markdown(f"""
+                    <div style="background-color: #28a745; color: white; text-align: center; padding: 8px; border-radius: 6px; margin: 2px; font-weight: bold; font-size: 14px;">
+                        {i + 1}
+                    </div>
+                    """, unsafe_allow_html=True)
+                elif i in st.session_state.get("answers", {}):
+                    st.markdown(f"""
+                    <div style="background-color: #d4edda; color: #155724; text-align: center; padding: 8px; border-radius: 6px; margin: 2px; font-size: 14px;">
+                        {i + 1}
+                    </div>
+                    """, unsafe_allow_html=True)
+                else:
+                    st.markdown(f"""
+                    <div style="background-color: #f8f9fa; color: #6c757d; text-align: center; padding: 8px; border-radius: 6px; margin: 2px; border: 1px solid #dee2e6; font-size: 14px;">
+                        {i + 1}
+                    </div>
+                    """, unsafe_allow_html=True)
+
+        st.markdown(f"""
+        <div style="font-size: 12px; color: #666; margin: 15px 0;">
+            <div style="margin: 5px 0;">
+                <span style="display: inline-block; width: 12px; height: 12px; background-color: #28a745; border-radius: 50%; margin-right: 8px;"></span>
+                <span>Answered ({answered_count})</span>
+            </div>
+            <div style="margin: 5px 0;">
+                <span style="display: inline-block; width: 12px; height: 12px; background-color: #17a2b8; border-radius: 50%; margin-right: 8px;"></span>
+                <span>Current</span>
+            </div>
+            <div style="margin: 5px 0;">
+                <span style="display: inline-block; width: 12px; height: 12px; background-color: #f8f9fa; border: 1px solid #dee2e6; border-radius: 50%; margin-right: 8px;"></span>
+                <span>Not answered</span>
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+
+        if st.button("← Back to Quizzes", use_container_width=True):
+            st.session_state.selected_quiz = None
+            st.rerun()
+
+# --- Quiz Question ---
+def show_quiz(quiz_id):
+    qobj = _load_quiz_obj(quiz_id)
+    q_index = int(st.session_state.current_q)
+    questions = qobj.get("questions", [])
+    question_data = questions[q_index]
+
+    st.header(qobj.get("title", "Quiz"))
+    st.subheader(question_data.get("question", ""))
+
+    options = question_data.get("options", [])
+    correct_answer = question_data.get("answer")
+    key = f"q_{q_index}"
+    prev_answer = st.session_state.answers.get(q_index)
+
+    if isinstance(correct_answer, list):
+        # multiselect; convert any letter defaults to texts
+        default_texts = []
+        if isinstance(prev_answer, list):
+            for a in prev_answer:
+                if isinstance(a, str):
+                    if a in options:
+                        default_texts.append(a)
+                    elif len(a) == 1 and a.isalpha():
+                        i = _letter_to_index(a)
+                        if 0 <= i < len(options):
+                            default_texts.append(options[i])
+        answer = st.multiselect("Select all that apply:", options, default=default_texts, key=key)
+    else:
+        # single answer; compute default index from letter or text
+        if isinstance(prev_answer, str):
+            if prev_answer in options:
+                default_idx = options.index(prev_answer)
+            elif len(prev_answer) == 1 and prev_answer.isalpha():
+                i = _letter_to_index(prev_answer)
+                default_idx = i if 0 <= i < len(options) else 0
+            else:
+                default_idx = 0
+        else:
+            default_idx = 0
+        answer = st.radio("Select your answer:", options, index=default_idx, key=key)
+
+    st.session_state.answers[q_index] = answer  # auto-save
+
+    if st.button("Next Question ➡"):
+        st.session_state.current_q += 1
+        st.rerun()
+
+
+
+# --- Quiz Results ---
+def show_results(quiz_id):
+    qobj = _load_quiz_obj(quiz_id)
+    questions = qobj.get("questions", [])
+
+    total_points = 0
+    earned_points = 0
+    details = {"answers": {}}
+
+    for i, q in enumerate(questions):
+        options = q.get("options", []) or []
+        pts = int(q.get("points", 1))
+        total_points += pts
+
+        correct = q.get("answer")
+        correct_idx = _correct_to_indices(correct, options)
+
+        user_answer = st.session_state.answers.get(i)
+        user_idx = _normalize_user_to_indices(user_answer, options)
+
+        is_correct = (sorted(user_idx) == sorted(correct_idx))
+        if is_correct:
+            earned_points += pts
+
+        # friendly display
+        correct_disp = ", ".join(options[j] for j in correct_idx if 0 <= j < len(options)) or str(correct)
+        user_disp = ", ".join(options[j] for j in user_idx if 0 <= j < len(options)) or (
+            ", ".join(user_answer) if isinstance(user_answer, list) else str(user_answer)
+        )
+
+        if is_correct:
+            st.markdown(f"✅ **Q{i+1}: {q.get('question','')}**  \nYour answer: {user_disp}")
+        else:
+            st.markdown(f"❌ **Q{i+1}: {q.get('question','')}**  \nYour answer: {user_disp}  \nCorrect answer: {correct_disp}")
+
+        details["answers"][str(i+1)] = {
+            "question": q.get("question", ""),
+            "selected": user_answer,
+            "correct": correct,
+            "points": pts,
+            "earned": pts if is_correct else 0
+        }
+
+    percent = int(round(100 * earned_points / max(1, total_points)))
+    st.success(f"{qobj.get('title','Quiz')} - Completed! 🎉")
+    st.markdown(f"### 🏆 Score: {percent}% ({earned_points}/{total_points} points)")
+
+    # Save submission to DB for assigned quizzes
+    if isinstance(quiz_id, int):
+        assignment_id = st.session_state.get("current_assignment")
+        if assignment_id:
+            _submit_quiz_result(
+                student_id=st.session_state.user["user_id"],
+                assignment_id=assignment_id,
+                quiz_id=quiz_id,
+                score=int(earned_points),
+                total=int(total_points),
+                details=details
+            )
+
+    if st.button("🔁 Retake Quiz"):
+        st.session_state.current_q = 0
+        st.session_state.answers = {}
+        st.rerun()
+
+    if st.button("⬅ Back to Quizzes"):
+        st.session_state.selected_quiz = None
+        st.rerun()
+
+    # tutor handoff (kept as-is)
+    wrong_answers = []
+    for i, q in enumerate(questions):
+        user_answer = st.session_state.answers.get(i)
+        correct = q.get("answer")
+        if (isinstance(correct, list) and set(user_answer or []) != set(correct)) or (not isinstance(correct, list) and user_answer != correct):
+            wrong_answers.append((q.get("question",""), user_answer, correct, q.get("explanation","")))
+    if wrong_answers and st.button("💬 Talk to AI Financial Tutor"):
+        st.session_state.selected_quiz = None
+        st.session_state.current_page = "Chatbot"
+        st.session_state.current_q = 0
+        st.session_state.answers = {}
+        if "messages" not in st.session_state:
+            st.session_state.messages = []
+        wrong_q_text = "\n".join(
+            [f"Q: {q}\nYour answer: {ua}\nCorrect answer: {ca}\nExplanation: {ex}"
+             for q, ua, ca, ex in wrong_answers])
+        tutor_prompt = f"I just completed a financial quiz and got some questions wrong. Here are the details:\n{wrong_q_text}\nCan you help me understand these concepts better?"
+        st.session_state.messages.append({
+            "id": str(datetime.datetime.now().timestamp()),
+            "text": tutor_prompt,
+            "sender": "user",
+            "timestamp": datetime.datetime.now()
+        })
+        st.session_state.is_typing = True
+        st.rerun()
+
+# --- Quiz List ---
+def show_quiz_list():
+    st.title("📊 Financial Knowledge Quizzes")
+    st.caption("Test your financial literacy across different modules")
+
+    cols = st.columns(3)
+    for i, (quiz_id, quiz) in enumerate(quizzes_data.items()):
+        col = cols[i % 3]
+        with col:
+            color, label = get_level_style(quiz["level"])
+            st.markdown(f"""
+            <div style="border:1px solid #e1e5e9; border-radius:12px; padding:20px; margin-bottom:20px; background:white; box-shadow:0 2px 6px rgba(0,0,0,0.08);">
+                <span style="background-color:{color}; color:white; font-size:12px; padding:4px 8px; border-radius:6px;">{label}</span>
+                <span style="float:right; color:#666; font-size:13px;">⏱ {quiz['duration']}</span>
+                <h4 style="margin-top:10px; margin-bottom:6px; color:#222;">{quiz['title']}</h4>
+                <p style="font-size:14px; color:#555; line-height:1.4; margin-bottom:10px;">{quiz['description']}</p>
+                <p style="font-size:13px; color:#666;">📝 {len(quiz['questions'])} questions</p>
+            </div>
+            """, unsafe_allow_html=True)
+
+            if st.button("Start Quiz ➡", key=f"quiz_{quiz_id}"):
+                st.session_state.selected_quiz = quiz_id
+                st.session_state.current_q = 0
+                st.session_state.answers = {}
+                st.rerun()
+
+
+# --- Main Router for Quiz Page ---
+def show_page():
+    if "selected_quiz" not in st.session_state:
+        st.session_state.selected_quiz = None
+    if "current_q" not in st.session_state:
+        st.session_state.current_q = 0
+    if "answers" not in st.session_state:
+        st.session_state.answers = {}
+
+    if st.session_state.selected_quiz is None:
+        show_quiz_list()
+    else:
+        quiz_id = st.session_state.selected_quiz
+        qobj = _load_quiz_obj(quiz_id)
+        total_q = len(qobj.get("questions", []))
+        if st.session_state.current_q < total_q:
+            show_quiz(quiz_id)
+        else:
+            show_results(quiz_id)

phase/Student_view/teacherlink.py

@@ -0,0 +1,243 @@
+# phase/Student_view/teacherlink.py
+import os
+import streamlit as st
+from utils import db as dbapi
+import utils.api as api  # <-- backend Space client
+
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"  # DB only when DISABLE_DB=0
+
+def load_css(file_name: str):
+    try:
+        with open(file_name, "r", encoding="utf-8") as f:
+            st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+    except FileNotFoundError:
+        pass
+
+def _progress_0_1(v):
+    try:
+        f = float(v)
+    except Exception:
+        return 0.0
+    # accept 0..1 or 0..100
+    return max(0.0, min(1.0, f if f <= 1.0 else f / 100.0))
+
+# --- Small wrappers to switch between DB and Backend ---
+
+def _join_class_by_code(student_id: int, code: str):
+    if USE_LOCAL_DB and hasattr(dbapi, "join_class_by_code"):
+        return dbapi.join_class_by_code(student_id, code)
+    return api.join_class_by_code(student_id, code)
+
+def _list_classes_for_student(student_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_classes_for_student"):
+        return dbapi.list_classes_for_student(student_id)
+    try:
+        return api.list_classes_for_student(student_id)
+    except Exception:
+        return []
+
+def _class_content_counts(class_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "class_content_counts"):
+        return dbapi.class_content_counts(class_id)
+    try:
+        return api.class_content_counts(class_id)
+    except Exception:
+        return {"lessons": 0, "quizzes": 0}
+
+def _student_class_progress(student_id: int, class_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "student_class_progress"):
+        return dbapi.student_class_progress(student_id, class_id)
+    try:
+        return api.student_class_progress(student_id, class_id)
+    except Exception:
+        return {
+            "overall_progress": 0,
+            "lessons_completed": 0,
+            "total_assigned_lessons": 0,
+            "avg_score": 0,
+        }
+
+def _leave_class(student_id: int, class_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "leave_class"):
+        return dbapi.leave_class(student_id, class_id)
+    return api.leave_class(student_id, class_id)
+
+def _student_assignments_for_class(student_id: int, class_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "student_assignments_for_class"):
+        return dbapi.student_assignments_for_class(student_id, class_id)
+    try:
+        return api.student_assignments_for_class(student_id, class_id)
+    except Exception:
+        return []
+
+# --- UI ---
+
+def show_code():
+    load_css(os.path.join("assets", "styles.css"))
+
+    if "user" not in st.session_state or not st.session_state.user:
+        st.error("Please log in as a student.")
+        return
+    if st.session_state.user["role"] != "Student":
+        st.error("This page is for students.")
+        return
+
+    student_id = st.session_state.user["user_id"]
+    st.markdown("## 👥 Join a Class")
+    st.caption("Enter class code from your teacher")
+
+    raw = st.text_input(
+        label="Class Code",
+        placeholder="e.g. FIN5A2024",
+        key="class_code_input",
+        label_visibility="collapsed"
+    )
+
+    # custom button style
+    st.markdown(
+        """
+        <style>
+        .stButton>button#join_class_btn {
+            background-color: #28a745; /* Bootstrap green */
+            color: white;
+            border-radius: 5px;
+            padding: 10px 16px;
+            font-weight: 600;
+        }
+        .stButton>button#join_class_btn:hover {
+            background-color: #218838;
+            color: white;
+        }
+        </style>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    if st.button("Join Class", key="join_class_btn"):
+        code = (raw or "").strip().upper()
+        if not code:
+            st.error("Enter a class code.")
+        else:
+            try:
+                _join_class_by_code(student_id, code)
+                st.success("🎉 Joined the class!")
+                st.rerun()
+            except ValueError as e:
+                st.error(str(e))
+            except Exception as e:
+                st.error(f"Could not join class: {e}")
+
+    st.markdown("---")
+    st.markdown("## Your Classes")
+
+    classes = _list_classes_for_student(student_id)
+    if not classes:
+        st.info("You haven’t joined any classes yet. Ask your teacher for a class code.")
+        return
+
+    # one card per class
+    for c in classes:
+        class_id = c["class_id"]
+        counts   = _class_content_counts(class_id)             # lessons/quizzes count
+        prog     = _student_class_progress(student_id, class_id)
+
+        st.markdown(f"### {c.get('name', 'Untitled Class')}")
+        st.caption(
+            f"Teacher: {c.get('teacher_name','—')} • "
+            f"Code: {c.get('code','—')} • "
+            f"Joined: {str(c.get('joined_at',''))[:10] if c.get('joined_at') else '—'}"
+        )
+
+        st.progress(_progress_0_1(prog.get("overall_progress", 0)))
+        avg_pct = int(round(100 * _progress_0_1(prog.get("avg_score", 0))))
+        st.caption(
+            f"{prog.get('lessons_completed', 0)}/{prog.get('total_assigned_lessons', 0)} lessons completed • "
+            f"Avg quiz: {avg_pct}%"
+        )
+
+        # top metrics
+        m1, m2, m3, m4 = st.columns(4)
+        m1.metric("Lessons", counts.get("lessons", 0))
+        m2.metric("Quizzes", counts.get("quizzes", 0))
+        m3.metric("Overall", f"{int(round(100 * _progress_0_1(prog.get('overall_progress', 0))))}%")
+        m4.metric("Avg Quiz", f"{avg_pct}%")
+
+        # Leave class
+        leave_col, _ = st.columns([1, 3])
+        with leave_col:
+            if st.button("🚪 Leave Class", key=f"leave_{class_id}"):
+                try:
+                    _leave_class(student_id, class_id)
+                    st.toast("Left class.", icon="👋")
+                    st.rerun()
+                except Exception as e:
+                    st.error(f"Could not leave class: {e}")
+
+        # Assignments for THIS class with THIS student's progress
+        st.markdown("#### Teacher Lessons & Quizzes")
+        rows = _student_assignments_for_class(student_id, class_id)
+        if not rows:
+            st.info("No assignments yet.")
+        else:
+            lessons_tab, quizzes_tab = st.tabs(["📘 Lessons", "🏆 Quizzes"])
+
+            with lessons_tab:
+                for r in rows:
+                    if r.get("lesson_id") is None:
+                        continue
+
+                    status = r.get("status") or "not_started"
+                    pos = r.get("current_pos") or 0
+                    # if backend returns explicit progress % or 0..1, keep it sane:
+                    pct = r.get("progress")
+                    if pct is None:
+                        # fallback: estimate from position
+                        pct = 1.0 if status == "completed" else min(0.95, float(pos or 0) * 0.1)
+
+                    st.subheader(r.get("title", "Untitled"))
+                    due = r.get("due_at")
+                    due_txt = f"Due: {str(due)[:10]}" if due else "—"
+                    st.caption(f"{r.get('subject','General')} • {r.get('level','Beginner')} • {due_txt}")
+                    st.progress(_progress_0_1(pct))
+
+                    c1, c2 = st.columns(2)
+                    with c1:
+                        # pass lesson & assignment to the Lessons page
+                        if st.button("▶️ Start Lesson", key=f"start_lesson_{r.get('assignment_id')}"):
+                            st.session_state.selected_lesson = r.get("lesson_id")
+                            st.session_state.selected_assignment = r.get("assignment_id")
+                            st.session_state.current_page = "Lessons"
+                            st.rerun()
+                    with c2:
+                        st.write(f"Status: **{status}**")
+
+            with quizzes_tab:
+                any_quiz = False
+                for r in rows:
+                    quiz_id = r.get("quiz_id")
+                    if not quiz_id:
+                        continue
+                    any_quiz = True
+
+                    st.subheader(r.get("title", "Untitled"))
+                    score, total = r.get("score"), r.get("total")
+                    if score is not None and total:
+                        try:
+                            pct = int(round(100 * float(score) / float(total)))
+                            st.caption(f"Last score: {pct}%")
+                        except Exception:
+                            st.caption("Last score: —")
+                    else:
+                        st.caption("No submission yet")
+
+                    # pass quiz & assignment to the Quiz page
+                    if st.button("📝 Start Quiz", key=f"start_quiz_{class_id}_{quiz_id}"):
+                        st.session_state.selected_quiz = quiz_id
+                        st.session_state.current_assignment = r.get("assignment_id")
+                        st.session_state.current_page = "Quiz"
+                        st.rerun()
+
+                if not any_quiz:
+                    st.info("No quizzes yet for this class.")
+
+        st.markdown("---")

phase/Teacher_view/classmanage.py

@@ -0,0 +1,188 @@
+# phase/Teacher_view/classmanage.py
+import os
+import streamlit as st
+
+from utils import db as dbapi
+import utils.api as api  # backend Space client
+
+# When DISABLE_DB=1 (default), skip direct MySQL and use backend APIs
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
+
+
+def _metric_card(label: str, value: str, caption: str = ""):
+    st.markdown(
+        f"""
+        <div class="metric-card">
+          <div class="metric-value">{value}</div>
+          <div class="metric-label">{label}</div>
+          <div class="metric-caption">{caption}</div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def _prefer_db(db_name: str, api_func, default, *args, **kwargs):
+    """
+    Try local DB function if enabled & present; else call backend API; else return default.
+    """
+    if USE_LOCAL_DB and hasattr(dbapi, db_name):
+        try:
+            return getattr(dbapi, db_name)(*args, **kwargs)
+        except Exception as e:
+            st.warning(f"DB call {db_name} failed; falling back to backend. ({e})")
+    try:
+        return api_func(*args, **kwargs)
+    except Exception as e:
+        st.error(f"Backend call failed: {e}")
+        return default
+
+
+def show_page():
+    user = st.session_state.user
+    teacher_id = user["user_id"]
+
+    st.title("📚 Classroom Management")
+    st.caption("Manage all your classrooms and students")
+
+    # -------- Create Classroom --------
+    with st.expander("➕ Create Classroom", expanded=False):
+        new_name = st.text_input("Classroom Name", key="new_classroom_name")
+        if st.button("Create Classroom"):
+            name = new_name.strip()
+            if not name:
+                st.error("Enter a real name, not whitespace.")
+            else:
+                out = _prefer_db(
+                    "create_class",
+                    lambda tid, n: api.create_class(tid, n),
+                    None,
+                    teacher_id,  # positional arg
+                    name,        # positional arg
+                )
+                if out:
+                    st.session_state.selected_class_id = out.get("class_id") or out.get("id")
+                    st.success(f'Classroom "{name}" created with code: {out.get("code","—")}')
+                    st.rerun()
+                else:
+                    st.error("Could not create classroom (no response).")
+
+    # -------- Load classes for this teacher --------
+    classes = _prefer_db(
+        "list_classes_by_teacher",
+        lambda tid: api.list_classes_by_teacher(tid),
+        [],
+        teacher_id,  # positional
+    )
+
+    if not classes:
+        st.info("No classrooms yet. Create one above, then share the code.")
+        return
+
+    # Picker
+    st.subheader("Your Classrooms")
+    options = {f"{c.get('name','(unnamed)')} (Code: {c.get('code','')})": c for c in classes}
+    selected_label = st.selectbox("Select a classroom", list(options.keys()))
+    selected = options[selected_label]
+    class_id = selected.get("class_id") or selected.get("id")
+
+    st.markdown("---")
+    st.header(selected.get("name", "Classroom"))
+
+    # -------- Code stripe --------
+    st.subheader("Class Code")
+    c1, c2, c3 = st.columns([3, 1, 1])
+    with c1:
+        st.markdown(f"**`{selected.get('code', 'UNKNOWN')}`**")
+    with c2:
+        if st.button("📋 Copy Code"):
+            st.toast("Code is shown above. Copy it.")
+    with c3:
+        st.button("🗑️ Delete Class", disabled=True, help="Soft-delete coming later")
+
+    # -------- Tabs --------
+    tab_students, tab_content, tab_analytics = st.tabs(["👥 Students", "📘 Content", "📊 Analytics"])
+
+    # ============== Students tab ==============
+    with tab_students:
+        q = st.text_input("Search students by name or email", "")
+        roster = _prefer_db(
+            "list_students_in_class",
+            lambda cid: api.list_students_in_class(cid),
+            [],
+            class_id,  # positional
+        )
+
+        # simple filter
+        if q.strip():
+            ql = q.lower()
+            roster = [r for r in roster if ql in (r.get("name","").lower()) or ql in (r.get("email","").lower())]
+
+        st.caption(f"{len(roster)} Students Found")
+
+        if not roster:
+            st.info("No students in this class yet.")
+        else:
+            for s in roster:
+                st.subheader(f"👤 {s.get('name','(unknown)')}")
+                st.caption(s.get("email","—"))
+                joined = s.get("joined_at") or s.get("created_at")
+                st.caption(f"📅 Joined: {str(joined)[:10] if joined else '—'}")
+                st.progress(0.0)  # placeholder bar
+                cols = st.columns(3)
+                level_slug = (s.get("level_slug") or s.get("level") or "beginner")
+                try:
+                    level_label = level_slug.capitalize() if isinstance(level_slug, str) else str(level_slug)
+                except Exception:
+                    level_label = "—"
+                cols[0].metric("⭐ Level", level_label)
+                cols[1].metric("📊 Avg Score", "—")
+                cols[2].metric("🔥 Streak", "—")
+                st.markdown("---")
+
+    # ============== Content tab ==============
+    with tab_content:
+        counts = _prefer_db(
+            "class_content_counts",
+            lambda cid: api.class_content_counts(cid),
+            {"lessons": 0, "quizzes": 0},
+            class_id,  # positional
+        )
+        left, right = st.columns(2)
+        with left:
+            _metric_card("📖 Custom Lessons", str(counts.get("lessons", 0)), "Lessons created for this classroom")
+        with right:
+            _metric_card("🏆 Custom Quizzes", str(counts.get("quizzes", 0)), "Quizzes created for this classroom")
+
+        assigs = _prefer_db(
+            "list_class_assignments",
+            lambda cid: api.list_class_assignments(cid),
+            [],
+            class_id,  # positional
+        )
+        if assigs:
+            st.markdown("#### Assigned items")
+            for a in assigs:
+                has_quiz = " + Quiz" if a.get("quiz_id") else ""
+                st.markdown(f"- **{a.get('title','Untitled')}** · {a.get('subject','—')} · {a.get('level','—')}{has_quiz}")
+
+    # ============== Analytics tab ==============
+    with tab_analytics:
+        stats = _prefer_db(
+            "class_analytics",
+            lambda cid: api.class_analytics(cid),
+            {"class_avg": 0.0, "total_xp": 0, "lessons_completed": 0},
+            class_id,  # positional
+        )
+
+        class_avg_pct = round(float(stats.get("class_avg", 0)) * 100) if stats.get("class_avg") is not None else 0
+        total_xp = stats.get("total_xp", 0)
+        lessons_completed = stats.get("lessons_completed", 0)
+
+        g1, g2, g3 = st.columns(3)
+        with g1:
+            _metric_card("📊 Class Average", f"{class_avg_pct}%", "Average quiz performance")
+        with g2:
+            _metric_card("🪙 Total XP", f"{total_xp}", "Combined XP earned")
+        with g3:
+            _metric_card("📘 Lessons Completed", f"{lessons_completed}", "Total lessons completed")

phase/Teacher_view/contentmanage.py

@@ -0,0 +1,688 @@
+# phase/Teacher_view/contentmanage.py
+import json
+import os
+from datetime import datetime
+import streamlit as st
+from utils import db as dbapi
+import utils.api as api  # backend Space client
+
+# Switch automatically: if DISABLE_DB=1 (default), use backend API; else use local DB
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
+
+# ---------- small UI helpers ----------
+def _pill(text):
+    return f"<span style='background:#eef6ff;border:1px solid #cfe3ff;border-radius:999px;padding:2px 8px;font-size:12px;margin-right:6px'>{text}</span>"
+
+def _progress(val: float):
+    pct = max(0, min(100, int(round(val * 100))))
+    return f"""
+    <div style="height:8px;background:#eef2ff;border-radius:999px;overflow:hidden">
+      <div style="width:{pct}%;height:100%;background:#3b82f6"></div>
+    </div>
+    """
+
+def _fmt_date(v):
+    if isinstance(v, datetime):
+        return v.strftime("%Y-%m-%d")
+    try:
+        s = str(v)
+        return s[:10]
+    except Exception:
+        return ""
+
+# ---------- Quiz generator via backend LLM (llama 3.1 8B) ----------
+def _generate_quiz_from_text(content: str, n_questions: int = 5, subject: str = "finance", level: str = "beginner"):
+    """
+    Calls your backend, which uses GEN_MODEL (llama-3.1-8b-instruct).
+    Returns a normalized list like:
+      [{"question":"...","options":["A","B","C","D"],"answer_key":"B","points":1}, ...]
+    """
+    def _normalize(items):
+        out = []
+        for it in (items or [])[:n_questions]:
+            q = str(it.get("question", "")).strip()
+            opts = it.get("options", [])
+            if not q or not isinstance(opts, list):
+                continue
+            while len(opts) < 4:
+                opts.append("Option")
+            opts = opts[:4]
+            key = str(it.get("answer_key", "A")).strip().upper()[:1]
+            if key not in ("A","B","C","D"):
+                key = "A"
+            out.append({"question": q, "options": opts, "answer_key": key, "points": 1})
+        return out
+
+    try:
+        resp = api.generate_quiz_from_text(content, n_questions=n_questions, subject=subject, level=level)
+        items = resp.get("items", resp)  # allow backend to return either shape
+        return _normalize(items)
+    except Exception as e:
+        with st.expander("Quiz generation error details"):
+            st.code(str(e))
+        st.warning("Quiz generation failed via backend. Check the /quiz/generate endpoint and GEN_MODEL.")
+        return []
+
+# ---------- Thin wrappers that choose DB or Backend ----------
+def _list_classes_by_teacher(teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_classes_by_teacher"):
+        return dbapi.list_classes_by_teacher(teacher_id)
+    try:
+        return api.list_classes_by_teacher(teacher_id)
+    except Exception:
+        return []
+
+def _list_all_students_for_teacher(teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_all_students_for_teacher"):
+        return dbapi.list_all_students_for_teacher(teacher_id)
+    try:
+        return api.list_all_students_for_teacher(teacher_id)
+    except Exception:
+        return []
+
+def _list_lessons_by_teacher(teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_lessons_by_teacher"):
+        return dbapi.list_lessons_by_teacher(teacher_id)
+    try:
+        return api.list_lessons_by_teacher(teacher_id)
+    except Exception:
+        return []
+
+def _list_quizzes_by_teacher(teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_quizzes_by_teacher"):
+        return dbapi.list_quizzes_by_teacher(teacher_id)
+    try:
+        return api.list_quizzes_by_teacher(teacher_id)
+    except Exception:
+        return []
+
+def _create_lesson(teacher_id: int, title: str, description: str, subject: str, level: str, sections: list[dict]):
+    if USE_LOCAL_DB and hasattr(dbapi, "create_lesson"):
+        return dbapi.create_lesson(teacher_id, title, description, subject, level, sections)
+    return api.create_lesson(teacher_id, title, description, subject, level, sections)
+
+def _update_lesson(lesson_id: int, teacher_id: int, title: str, description: str, subject: str, level: str, sections: list[dict]):
+    if USE_LOCAL_DB and hasattr(dbapi, "update_lesson"):
+        return dbapi.update_lesson(lesson_id, teacher_id, title, description, subject, level, sections)
+    return api.update_lesson(lesson_id, teacher_id, title, description, subject, level, sections)
+
+def _delete_lesson(lesson_id: int, teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "delete_lesson"):
+        return dbapi.delete_lesson(lesson_id, teacher_id)
+    return api.delete_lesson(lesson_id, teacher_id)
+
+def _get_lesson(lesson_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "get_lesson"):
+        return dbapi.get_lesson(lesson_id)
+    return api.get_lesson(lesson_id)
+
+def _create_quiz(lesson_id: int, title: str, items: list[dict], settings: dict):
+    if USE_LOCAL_DB and hasattr(dbapi, "create_quiz"):
+        return dbapi.create_quiz(lesson_id, title, items, settings)
+    return api.create_quiz(lesson_id, title, items, settings)
+
+def _update_quiz(quiz_id: int, teacher_id: int, title: str, items: list[dict], settings: dict):
+    if USE_LOCAL_DB and hasattr(dbapi, "update_quiz"):
+        return dbapi.update_quiz(quiz_id, teacher_id, title, items, settings)
+    return api.update_quiz(quiz_id, teacher_id, title, items, settings)
+
+def _delete_quiz(quiz_id: int, teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "delete_quiz"):
+        return dbapi.delete_quiz(quiz_id, teacher_id)
+    return api.delete_quiz(quiz_id, teacher_id)
+
+def _list_assigned_students_for_lesson(lesson_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_assigned_students_for_lesson"):
+        return dbapi.list_assigned_students_for_lesson(lesson_id)
+    return api.list_assigned_students_for_lesson(lesson_id)
+
+def _list_assigned_students_for_quiz(quiz_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_assigned_students_for_quiz"):
+        return dbapi.list_assigned_students_for_quiz(quiz_id)
+    return api.list_assigned_students_for_quiz(quiz_id)
+
+def _assign_to_class(lesson_id: int | None, quiz_id: int | None, class_id: int, teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "assign_to_class"):
+        return dbapi.assign_to_class(lesson_id, quiz_id, class_id, teacher_id)
+    return api.assign_to_class(lesson_id, quiz_id, class_id, teacher_id)
+
+# ---------- Create panels ----------
+def _create_lesson_panel(teacher_id: int):
+    st.markdown("### ✍️ Create New Lesson")
+
+    classes = _list_classes_by_teacher(teacher_id)
+    class_opts = {f"{c['name']} (code {c['code']})": c["class_id"] for c in classes} if classes else {}
+
+    if "cl_topic_count" not in st.session_state:
+        st.session_state.cl_topic_count = 2  # start with two topics
+
+    cols_btn = st.columns([1,1,6])
+    with cols_btn[0]:
+        if st.button("➕ Add topic", type="secondary"):
+            st.session_state.cl_topic_count = min(20, st.session_state.cl_topic_count + 1)
+            st.rerun()
+    with cols_btn[1]:
+        if st.button("➖ Remove last", type="secondary", disabled=st.session_state.cl_topic_count <= 1):
+            st.session_state.cl_topic_count = max(1, st.session_state.cl_topic_count - 1)
+            st.rerun()
+
+    with st.form("create_lesson_form", clear_on_submit=False):
+        c1, c2 = st.columns([2,1])
+        title = c1.text_input("Title", placeholder="e.g., Jamaican Money Recognition")
+        level = c2.selectbox("Level", ["beginner","intermediate","advanced"], index=0)
+        description = st.text_area("Short description")
+        subject = st.selectbox("Subject", ["numeracy","finance"], index=0)
+
+        st.markdown("#### Topics")
+        topic_rows = []
+        for i in range(1, st.session_state.cl_topic_count + 1):
+            with st.expander(f"Topic {i}", expanded=True if i <= 2 else False):
+                t = st.text_input(f"Topic {i} title", key=f"t_title_{i}")
+                b = st.text_area(f"Topic {i} content", key=f"t_body_{i}", height=150)
+                topic_rows.append((t, b))
+
+        add_summary = st.checkbox("Append a Summary section at the end", value=True)
+        summary_text = ""
+        if add_summary:
+            summary_text = st.text_area(
+                "Summary notes",
+                key="summary_notes",
+                height=120,
+                placeholder="Key ideas, local examples, common mistakes, quick recap..."
+            )
+
+        st.markdown("#### Assign to class (optional)")
+        assign_classes = st.multiselect("Choose one or more classes", list(class_opts.keys()))
+
+        st.markdown("#### Auto-generate a quiz from this lesson (optional)")
+        gen_quiz = st.checkbox("Generate a quiz from content", value=False)
+        q_count = st.slider("", 3, 10, 5)
+
+        submitted = st.form_submit_button("Create lesson", type="primary")
+
+    if not submitted:
+        return
+
+    sections = []
+    for t, b in topic_rows:
+        if (t or b):
+            sections.append({"title": t or "Topic", "content": b or ""})
+
+    if add_summary:
+        sections.append({
+            "title": "Summary",
+            "content": (summary_text or "Write a short recap of the most important ideas.").strip()
+        })
+
+    if not title or not sections:
+        st.error("Please add a title and at least one topic.")
+        return
+
+    # create lesson (DB or backend)
+    try:
+        lesson_id = _create_lesson(teacher_id, title, description, subject, level, sections)
+        st.success(f"✅ Lesson created (ID {lesson_id}).")
+    except Exception as e:
+        st.error(f"Failed to create lesson: {e}")
+        return
+
+    # assign to chosen classes (lesson only for now)
+    for label in assign_classes:
+        try:
+            _assign_to_class(lesson_id, None, class_opts[label], teacher_id)
+        except Exception as e:
+            st.warning(f"Could not assign to {label}: {e}")
+
+    # auto-generate quiz via backend LLM
+    if gen_quiz:
+        text = "\n\n".join([s["title"] + "\n" + (s["content"] or "") for s in sections])
+        with st.spinner("Generating quiz from lesson content..."):
+            items = _generate_quiz_from_text(text, n_questions=q_count, subject=subject, level=level)
+        if items:
+            try:
+                qid = _create_quiz(lesson_id, f"{title} - Quiz", items, {})
+                st.success(f"🧠 Quiz generated and saved (ID {qid}).")
+                for label in assign_classes:
+                    _assign_to_class(lesson_id, qid, class_opts[label], teacher_id)
+            except Exception as e:
+                st.warning(f"Lesson saved, but failed to save quiz: {e}")
+
+    st.session_state.show_create_lesson = False
+    st.rerun()
+
+def _create_quiz_panel(teacher_id: int):
+    st.markdown("### 🏆 Create New Quiz")
+
+    lessons = _list_lessons_by_teacher(teacher_id)
+    lesson_map = {f"{L['title']} (#{L['lesson_id']})": L["lesson_id"] for L in lessons}
+    if not lesson_map:
+        st.info("Create a lesson first, then link a quiz to it.")
+        return
+
+    if "cq_q_count" not in st.session_state:
+        st.session_state.cq_q_count = 5
+
+    with st.form("create_quiz_form", clear_on_submit=False):
+        c1, c2 = st.columns([2,1])
+        title = c1.text_input("Title", placeholder="e.g., Currency Basics Quiz")
+        lesson_label = c2.selectbox("Linked Lesson", list(lesson_map.keys()))
+
+        st.markdown("#### Questions (up to 10)")
+        items = []
+        for i in range(1, st.session_state.cq_q_count + 1):
+            with st.expander(f"Question {i}", expanded=(i <= 2)):
+                q = st.text_area(f"Prompt {i}", key=f"q_{i}")
+                cA, cB = st.columns(2)
+                a = cA.text_input(f"Option A (correct?)", key=f"optA_{i}")
+                b = cB.text_input(f"Option B", key=f"optB_{i}")
+                cC, cD = st.columns(2)
+                c = cC.text_input(f"Option C", key=f"optC_{i}")
+                d = cD.text_input(f"Option D", key=f"optD_{i}")
+                correct = st.radio("Correct answer", ["A","B","C","D"], index=0, key=f"ans_{i}", horizontal=True)
+                items.append({"question": q, "options": [a,b,c,d], "answer_key": correct, "points": 1})
+
+        row = st.columns([1,1,4,2])
+        with row[0]:
+            if st.form_submit_button("➕ Add question", type="secondary", disabled=st.session_state.cq_q_count >= 10):
+                st.session_state.cq_q_count = min(10, st.session_state.cq_q_count + 1)
+                st.rerun()
+        with row[1]:
+            if st.form_submit_button("➖ Remove last", type="secondary", disabled=st.session_state.cq_q_count <= 1):
+                st.session_state.cq_q_count = max(1, st.session_state.cq_q_count - 1)
+                st.rerun()
+
+        submitted = row[3].form_submit_button("Create quiz", type="primary")
+
+    if not submitted:
+        return
+    if not title:
+        st.error("Please add a quiz title.")
+        return
+
+    cleaned = []
+    for it in items:
+        q = (it["question"] or "").strip()
+        opts = [o for o in it["options"] if (o or "").strip()]
+        if len(opts) < 2 or not q:
+            continue
+        while len(opts) < 4:
+            opts.append("Option")
+        cleaned.append({"question": q, "options": opts[:4], "answer_key": it["answer_key"], "points": 1})
+
+    if not cleaned:
+        st.error("Add at least one valid question.")
+        return
+
+    try:
+        qid = _create_quiz(lesson_map[lesson_label], title, cleaned, {})
+        st.success(f"✅ Quiz created (ID {qid}).")
+        st.session_state.show_create_quiz = False
+        st.rerun()
+    except Exception as e:
+        st.error(f"Failed to create quiz: {e}")
+
+def _edit_lesson_panel(teacher_id: int, lesson_id: int):
+    try:
+        data = _get_lesson(lesson_id)
+    except Exception as e:
+        st.error(f"Could not load lesson #{lesson_id}: {e}")
+        return
+
+    L = data.get("lesson", {})
+    secs = data.get("sections", []) or []
+
+    key_cnt = f"el_cnt_{lesson_id}"
+    if key_cnt not in st.session_state:
+        st.session_state[key_cnt] = max(1, len(secs))
+
+    st.markdown("### ✏️ Edit Lesson")
+
+    tools = st.columns([1,1,8])
+    with tools[0]:
+        if st.button("➕ Add section", key=f"el_add_{lesson_id}", use_container_width=True):
+            st.session_state[key_cnt] = min(50, st.session_state[key_cnt] + 1)
+            st.rerun()
+    with tools[1]:
+        if st.button("➖ Remove last", key=f"el_rem_{lesson_id}",
+                     disabled=st.session_state[key_cnt] <= 1, use_container_width=True):
+            st.session_state[key_cnt] = max(1, st.session_state[key_cnt] - 1)
+            st.rerun()
+
+    with st.form(f"edit_lesson_form_{lesson_id}", clear_on_submit=False):
+        c1, c2 = st.columns([2,1])
+        title = c1.text_input("Title", value=L.get("title") or "")
+        level = c2.selectbox(
+            "Level",
+            ["beginner","intermediate","advanced"],
+            index=["beginner","intermediate","advanced"].index(L.get("level") or "beginner")
+        )
+        description = st.text_area("Short description", value=L.get("description") or "")
+        subject = st.selectbox("Subject", ["numeracy","finance"], index=(0 if (L.get("subject")=="numeracy") else 1))
+
+        st.markdown("#### Sections")
+        edited_sections = []
+        total = st.session_state[key_cnt]
+        for i in range(1, total + 1):
+            s = secs[i-1] if i-1 < len(secs) else {"title":"", "content":""}
+            with st.expander(f"Section {i}", expanded=(i <= 2)):
+                t = st.text_input(f"Title {i}", value=s.get("title") or "", key=f"el_t_{lesson_id}_{i}")
+                b = st.text_area(f"Content {i}", value=s.get("content") or "", height=150, key=f"el_b_{lesson_id}_{i}")
+                edited_sections.append({"title": t or "Section", "content": b or ""})
+
+        save = st.form_submit_button("💾 Save changes", type="primary", use_container_width=True)
+
+    actions = st.columns([8,2])
+    with actions[1]:
+        cancel_clicked = st.button("✖ Cancel", key=f"el_cancel_{lesson_id}", type="secondary", use_container_width=True)
+
+    if cancel_clicked:
+        st.session_state.show_edit_lesson = False
+        st.session_state.edit_lesson_id = None
+        st.rerun()
+
+    if not save:
+        return
+
+    if not title or not any((s["title"] or s["content"]).strip() for s in edited_sections):
+        st.error("Title and at least one non-empty section are required.")
+        return
+
+    ok = False
+    try:
+        ok = _update_lesson(lesson_id, teacher_id, title, description, subject, level, edited_sections)
+    except Exception as e:
+        st.error(f"Update failed: {e}")
+
+    if ok:
+        st.success("✅ Lesson updated.")
+        st.session_state.show_edit_lesson = False
+        st.session_state.edit_lesson_id = None
+        st.rerun()
+    else:
+        st.error("Could not update this lesson. Check ownership or backend errors.")
+
+def _edit_quiz_panel(teacher_id: int, quiz_id: int):
+    # Load quiz
+    try:
+        data = (dbapi.get_quiz(quiz_id) if (USE_LOCAL_DB and hasattr(dbapi, "get_quiz")) else api._req("GET", f"/quizzes/{quiz_id}").json())
+    except Exception as e:
+        st.error(f"Quiz not found: {e}")
+        return
+
+    Q = data.get("quiz")
+    raw_items = data.get("items", [])
+    if not Q:
+        st.error("Quiz not found.")
+        return
+
+    def _dec(x):
+        if isinstance(x, str):
+            try:
+                return json.loads(x)
+            except Exception:
+                return x
+        return x
+
+    items = []
+    for it in raw_items:
+        opts = _dec(it.get("options")) or []
+        while len(opts) < 4:
+            opts.append("Option")
+        opts = opts[:4]
+
+        ans = _dec(it.get("answer_key"))
+        if isinstance(ans, list) and ans:
+            ans = ans[0]
+        ans = (str(ans) or "A").upper()[:1]
+        if ans not in ("A","B","C","D"):
+            ans = "A"
+
+        items.append({
+            "question": (it.get("question") or "").strip(),
+            "options": opts,
+            "answer_key": ans,
+            "points": int(it.get("points") or 1),
+        })
+
+    key_cnt = f"eq_cnt_{quiz_id}"
+    if key_cnt not in st.session_state:
+        st.session_state[key_cnt] = max(1, len(items) or 5)
+
+    st.markdown("### ✏️ Edit Quiz")
+
+    with st.form(f"edit_quiz_form_{quiz_id}", clear_on_submit=False):
+        title = st.text_input("Title", value=Q.get("title") or f"Quiz #{quiz_id}")
+
+        edited = []
+        total = st.session_state[key_cnt]
+        for i in range(1, total + 1):
+            it = items[i-1] if i-1 < len(items) else {"question":"", "options":["","","",""], "answer_key":"A", "points":1}
+            with st.expander(f"Question {i}", expanded=(i <= 2)):
+                q = st.text_area(f"Prompt {i}", value=it["question"], key=f"eq_q_{quiz_id}_{i}")
+                cA, cB = st.columns(2)
+                a = cA.text_input(f"Option A", value=it["options"][0], key=f"eq_A_{quiz_id}_{i}")
+                b = cB.text_input(f"Option B", value=it["options"][1], key=f"eq_B_{quiz_id}_{i}")
+                cC, cD = st.columns(2)
+                c = cC.text_input(f"Option C", value=it["options"][2], key=f"eq_C_{quiz_id}_{i}")
+                d = cD.text_input(f"Option D", value=it["options"][3], key=f"eq_D_{quiz_id}_{i}")
+                correct = st.radio("Correct answer", ["A","B","C","D"],
+                                   index=["A","B","C","D"].index(it["answer_key"]),
+                                   key=f"eq_ans_{quiz_id}_{i}", horizontal=True)
+                edited.append({"question": q, "options": [a,b,c,d], "answer_key": correct, "points": 1})
+
+        row = st.columns([1,1,6,2,2])
+        with row[0]:
+            if st.form_submit_button("➕ Add question", type="secondary"):
+                st.session_state[key_cnt] = min(20, st.session_state[key_cnt] + 1)
+                st.rerun()
+        with row[1]:
+            if st.form_submit_button("➖ Remove last", type="secondary", disabled=st.session_state[key_cnt] <= 1):
+                st.session_state[key_cnt] = max(1, st.session_state[key_cnt] - 1)
+                st.rerun()
+
+        save = row[3].form_submit_button("💾 Save", type="primary")
+        cancel = row[4].form_submit_button("✖ Cancel", type="secondary")
+
+    if cancel:
+        st.session_state.show_edit_quiz = False
+        st.session_state.edit_quiz_id = None
+        st.rerun()
+
+    if not save:
+        return
+
+    cleaned = []
+    for it in edited:
+        q = (it["question"] or "").strip()
+        opts = [o for o in it["options"] if (o or "").strip()]
+        if not q or len(opts) < 2:
+            continue
+        while len(opts) < 4:
+            opts.append("Option")
+        cleaned.append({
+            "question": q,
+            "options": opts[:4],
+            "answer_key": it["answer_key"],
+            "points": 1
+        })
+
+    if not title or not cleaned:
+        st.error("Title and at least one valid question are required.")
+        return
+
+    ok = False
+    try:
+        ok = _update_quiz(quiz_id, teacher_id, title, cleaned, settings={})
+    except Exception as e:
+        st.error(f"Save failed: {e}")
+
+    if ok:
+        st.success("✅ Quiz updated.")
+        st.session_state.show_edit_quiz = False
+        st.session_state.edit_quiz_id = None
+        st.rerun()
+    else:
+        st.error("Could not update this quiz. Check ownership or backend errors.")
+
+# ---------- Main page ----------
+def show_page():
+    user = st.session_state.user
+    teacher_id = user["user_id"]
+
+    st.title("📚 Content Management")
+    st.caption("Create and manage custom lessons and quizzes")
+
+    # preload lists
+    lessons = _list_lessons_by_teacher(teacher_id)
+    quizzes = _list_quizzes_by_teacher(teacher_id)
+
+    # top action bar
+    a1, a2, _sp = st.columns([3,3,4])
+    if a1.button("➕ Create Lesson", use_container_width=True):
+        st.session_state.show_create_lesson = True
+    if a2.button("🏆 Create Quiz", use_container_width=True):
+        st.session_state.show_create_quiz = True
+
+    # create panels
+    if st.session_state.get("show_create_lesson"):
+        with st.container(border=True):
+            _create_lesson_panel(teacher_id)
+        st.markdown("---")
+
+    if st.session_state.get("show_create_quiz"):
+        with st.container(border=True):
+            _create_quiz_panel(teacher_id)
+        st.markdown("---")
+
+    # inline editors
+    if st.session_state.get("show_edit_lesson") and st.session_state.get("edit_lesson_id"):
+        with st.container(border=True):
+            _edit_lesson_panel(teacher_id, st.session_state.edit_lesson_id)
+        st.markdown("---")
+
+    if st.session_state.get("show_edit_quiz") and st.session_state.get("edit_quiz_id"):
+        with st.container(border=True):
+            _edit_quiz_panel(teacher_id, st.session_state.edit_quiz_id)
+        st.markdown("---")
+
+    # Tabs
+    tab1, tab2 = st.tabs([f"Custom Lessons ({len(lessons)})", f"Custom Quizzes ({len(quizzes)})"])
+
+    # ========== LESSONS ==========
+    with tab1:
+        if not lessons:
+            st.info("No lessons yet. Use **Create Lesson** above.")
+        else:
+            all_students = _list_all_students_for_teacher(teacher_id)
+            student_options = {f"{s['name']} · {s['email']}": s["user_id"] for s in all_students}
+
+            for L in lessons:
+                assignees = _list_assigned_students_for_lesson(L["lesson_id"])
+                assignee_names = [a.get("name") for a in assignees]
+                created = _fmt_date(L.get("created_at"))
+                count = len(assignees)
+
+                with st.container(border=True):
+                    c1, c2 = st.columns([8,3])
+                    with c1:
+                        st.markdown(f"### {L['title']}")
+                        st.caption(L.get("description") or "")
+                        st.markdown(
+                            _pill((L.get("level") or "beginner").capitalize()) +
+                            _pill(L.get("subject","finance")) +
+                            _pill(f"{count} student{'s' if count != 1 else ''} assigned") +
+                            _pill(f"Created {created}"),
+                            unsafe_allow_html=True
+                        )
+                    with c2:
+                        b1, b2 = st.columns([1,1])
+                        with b1:
+                            if st.button("Edit", key=f"edit_{L['lesson_id']}"):
+                                st.session_state.edit_lesson_id = L["lesson_id"]
+                                st.session_state.show_edit_lesson = True
+                                st.rerun()
+                        with b2:
+                            if st.button("Delete", key=f"del_{L['lesson_id']}"):
+                                ok, msg = _delete_lesson(L["lesson_id"], teacher_id)
+                                if ok: st.success("Lesson deleted"); st.rerun()
+                                else:  st.error(msg or "Delete failed")
+
+                    st.markdown("**Assigned Students:**")
+                    if assignee_names:
+                        st.markdown(" ".join(_pill(n) for n in assignee_names if n), unsafe_allow_html=True)
+                    else:
+                        st.caption("No students assigned yet.")
+
+    # ========== QUIZZES ==========
+    with tab2:
+        if not quizzes:
+            st.info("No quizzes yet. Use **Create Quiz** above.")
+        else:
+            for Q in quizzes:
+                assignees = _list_assigned_students_for_quiz(Q["quiz_id"])
+                created = _fmt_date(Q.get("created_at"))
+                num_qs = int(Q.get("num_items", 0))
+
+                with st.container(border=True):
+                    c1, c2 = st.columns([8,3])
+                    with c1:
+                        st.markdown(f"### {Q['title']}")
+                        st.caption(f"Lesson: {Q.get('lesson_title','')}")
+                        st.markdown(
+                            _pill(f"{num_qs} question{'s' if num_qs != 1 else ''}") +
+                            _pill(f"{len(assignees)} students assigned") +
+                            _pill(f"Created {created}"),
+                            unsafe_allow_html=True
+                        )
+                    with c2:
+                        b1, b2 = st.columns(2)
+                        with b1:
+                            if st.button("Edit", key=f"editq_{Q['quiz_id']}"):
+                                st.session_state.edit_quiz_id = Q["quiz_id"]
+                                st.session_state.show_edit_quiz = True
+                                st.rerun()
+                        with b2:
+                            if st.button("Delete", key=f"delq_{Q['quiz_id']}"):
+                                ok, msg = _delete_quiz(Q["quiz_id"], teacher_id)
+                                if ok: st.success("Quiz deleted"); st.rerun()
+                                else:  st.error(msg or "Delete failed")
+
+                    st.markdown("**Assigned Students:**")
+                    if assignees:
+                        st.markdown(" ".join(_pill(a.get('name')) for a in assignees if a.get('name')), unsafe_allow_html=True)
+                    else:
+                        st.caption("No students assigned yet.")
+
+                    with st.expander("View questions", expanded=False):
+                        # Load items on demand to avoid heavy initial load
+                        try:
+                            data = (dbapi.get_quiz(Q["quiz_id"]) if (USE_LOCAL_DB and hasattr(dbapi, "get_quiz"))
+                                    else api._req("GET", f"/quizzes/{Q['quiz_id']}").json())
+                        except Exception as e:
+                            st.info(f"Could not fetch items: {e}")
+                            data = None
+                        items = data.get("items", []) if data else []
+                        if not items:
+                            st.info("No items found for this quiz.")
+                        else:
+                            labels = ["A","B","C","D"]
+                            for i, it in enumerate(items, start=1):
+                                opts = it.get("options")
+                                if isinstance(opts, str):
+                                    try:
+                                        opts = json.loads(opts)
+                                    except Exception:
+                                        opts = [opts]
+                                answer = it.get("answer_key")
+                                if isinstance(answer, str):
+                                    try:
+                                        answer = json.loads(answer)
+                                    except Exception:
+                                        pass
+
+                                st.markdown(f"**Q{i}.** {it.get('question','').strip()}")
+                                for j, opt in enumerate((opts or [])[:4]):
+                                    st.write(f"{labels[j]}) {opt}")
+                                ans_text = answer if isinstance(answer, str) else ",".join(answer or [])
+                                st.caption(f"Answer: {ans_text}")
+                                st.markdown("---")

phase/Teacher_view/studentlist.py

@@ -0,0 +1,233 @@
+# phase/Teacher_view/studentlist.py
+import os
+import streamlit as st
+from utils import db as dbapi
+import utils.api as api  # backend Space client
+
+# Use local DB only when DISABLE_DB != "1"
+USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
+
+# ---------- tiny helpers ----------
+def _avatar(name: str) -> str:
+    return "🧑‍🎓" if hash(name) % 2 else "👩‍🎓"
+
+def _avg_pct_from_row(r) -> int:
+    """
+    Accepts either:
+      - r['avg_pct'] in [0, 100]
+      - r['avg_score'] in [0, 1] or [0, 100]
+    Returns an int 0..100.
+    """
+    v = r.get("avg_pct", r.get("avg_score", 0)) or 0
+    try:
+        f = float(v)
+        if f <= 1.0:  # treat as 0..1
+            f *= 100.0
+        return max(0, min(100, int(round(f))))
+    except Exception:
+        return 0
+
+def _level_from_xp(total_xp: int) -> int:
+    try:
+        xp = int(total_xp or 0)
+    except Exception:
+        xp = 0
+    return 1 + xp // 500
+
+def _report_text(r, level, avg_pct):
+    return (
+        "STUDENT PROGRESS REPORT\n"
+        "======================\n"
+        f"Student: {r.get('name','')}\n"
+        f"Email: {r.get('email','')}\n"
+        f"Joined: {str(r.get('joined_at',''))[:10]}\n\n"
+        "PROGRESS OVERVIEW\n"
+        "-----------------\n"
+        f"Lessons Completed: {int(r.get('lessons_completed') or 0)}/{int(r.get('total_assigned_lessons') or 0)}\n"
+        f"Average Quiz Score: {avg_pct}%\n"
+        f"Total XP: {int(r.get('total_xp') or 0)}\n"
+        f"Current Level: {level}\n"
+        f"Study Streak: {int(r.get('streak_days') or 0)} days\n"
+    )
+
+ROW_CSS = """
+<style>
+.sm-chip{display:inline-block;padding:4px 10px;border-radius:999px;background:#eef7f1;color:#0b8f5d;font-weight:600;font-size:.80rem;margin-left:8px}
+.sm-pill{display:inline-flex;align-items:center;gap:6px;padding:6px 12px;border:1px solid #e6e6e6;border-radius:8px;background:#fff}
+.sm-row{border:1px solid #eee;border-radius:12px;padding:16px 16px;margin:10px 0;background:#fff}
+.sm-row:hover{box-shadow:0 2px 10px rgba(0,0,0,.04)}
+.sm-right{display:flex;gap:16px;align-items:center;justify-content:flex-end}
+.sm-metric{min-width:90px;text-align:right}
+.sm-metric .label{color:#777;font-size:.75rem}
+.sm-metric .value{font-weight:700;font-size:1.1rem}
+.sm-name{font-size:1.05rem;font-weight:700}
+.sm-sub{color:#6c6c6c;font-size:.85rem}
+</style>
+"""
+
+# ---------- data access (DB or Backend) ----------
+@st.cache_data(show_spinner=False, ttl=30)
+def _list_classes_by_teacher(teacher_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_classes_by_teacher"):
+        return dbapi.list_classes_by_teacher(teacher_id) or []
+    try:
+        return api.list_classes_by_teacher(teacher_id) or []
+    except Exception:
+        return []
+
+@st.cache_data(show_spinner=False, ttl=30)
+def _get_class(class_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "get_class"):
+        return dbapi.get_class(class_id) or {}
+    try:
+        return api.get_class(class_id) or {}
+    except Exception:
+        return {}
+
+@st.cache_data(show_spinner=False, ttl=30)
+def _class_student_metrics(class_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "class_student_metrics"):
+        return dbapi.class_student_metrics(class_id) or []
+    try:
+        return api.class_student_metrics(class_id) or []
+    except Exception:
+        return []
+
+@st.cache_data(show_spinner=False, ttl=30)
+def _list_assignments_for_student(student_id: int):
+    if USE_LOCAL_DB and hasattr(dbapi, "list_assignments_for_student"):
+        return dbapi.list_assignments_for_student(student_id) or []
+    try:
+        return api.list_assignments_for_student(student_id) or []
+    except Exception:
+        return []
+
+# ---------- page ----------
+def show_page():
+    st.title("🎓 Student Management")
+    st.caption("Monitor and manage your students' progress")
+    st.markdown(ROW_CSS, unsafe_allow_html=True)
+
+    teacher = st.session_state.get("user")
+    if not teacher:
+        st.error("Please log in.")
+        return
+    teacher_id = teacher["user_id"]
+
+    classes = _list_classes_by_teacher(teacher_id)
+    if not classes:
+        st.info("No classes yet. Create one in Classroom Management.")
+        return
+
+    # class selector
+    idx = st.selectbox(
+        "Choose a class",
+        list(range(len(classes))),
+        index=0,
+        format_func=lambda i: f"{classes[i].get('name','(unnamed)')}"
+    )
+    selected = classes[idx]
+    class_id = selected.get("class_id") or selected.get("id")  # be tolerant to backend naming
+    if class_id is None:
+        st.error("Selected class is missing an ID.")
+        return
+
+    code_row = _get_class(class_id)
+
+    # get students before drawing chips
+    rows = _class_student_metrics(class_id)
+
+    # code + student chip row
+    chip1, chip2 = st.columns([1, 1])
+    with chip1:
+        st.markdown(
+            f'<div class="sm-chip">Code: {code_row.get("code","")}</div>',
+            unsafe_allow_html=True
+        )
+    with chip2:
+        st.markdown(
+            f'<div class="sm-chip">👥 {len(rows)} Students</div>',
+            unsafe_allow_html=True
+        )
+
+    st.markdown("---")
+
+    # search line
+    query = st.text_input(
+        "Search students by name or email",
+        placeholder="Type a name or email..."
+    ).strip().lower()
+
+    if query:
+        rows = [
+            r for r in rows
+            if query in (r.get("name","").lower()) or query in (r.get("email","").lower())
+        ]
+
+    # student rows
+    for r in rows:
+        name = r.get("name", "Unknown")
+        email = r.get("email", "")
+        joined = str(r.get("joined_at", ""))[:10]
+        total_xp = int(r.get("total_xp") or 0)
+        level = _level_from_xp(total_xp)
+        lessons_completed = int(r.get("lessons_completed") or 0)
+        total_assigned = int(r.get("total_assigned_lessons") or 0)
+        avg_pct = _avg_pct_from_row(r)
+        streak = int(r.get("streak_days") or 0)
+        student_id = r.get("student_id") or r.get("id")
+
+        with st.container():
+            st.markdown('<div class="sm-row">', unsafe_allow_html=True)
+
+            # top bar: avatar + name/email + right metrics
+            a, b, c = st.columns([0.7, 4, 3])
+            with a:
+                st.markdown(f"### {_avatar(name)}")
+            with b:
+                st.markdown(f'<div class="sm-name">{name}</div>', unsafe_allow_html=True)
+                st.markdown(f'<div class="sm-sub">{email}  ·  Joined {joined}</div>', unsafe_allow_html=True)
+            with c:
+                st.markdown(
+                    '<div class="sm-right">'
+                    f'<div class="sm-metric"><div class="value">{level}</div><div class="label">Level</div></div>'
+                    f'<div class="sm-metric"><div class="value">{avg_pct}%</div><div class="label">Avg Score</div></div>'
+                    f'<div class="sm-metric"><div class="value">{streak}</div><div class="label">Streak</div></div>'
+                    "</div>",
+                    unsafe_allow_html=True
+                )
+
+            # progress bar
+            st.caption("Overall Progress")
+            frac = (lessons_completed / total_assigned) if total_assigned > 0 else 0.0
+            st.progress(min(1.0, frac))
+            st.caption(f"{lessons_completed}/{total_assigned} lessons")
+
+            # actions row
+            d1, d2, spacer = st.columns([2, 1.3, 5])
+            with d1:
+                with st.popover("👁️ View Details"):
+                    if student_id is not None:
+                        items = _list_assignments_for_student(int(student_id))
+                    else:
+                        items = []
+                    if items:
+                        for it in items[:25]:
+                            tag = " + Quiz" if it.get("quiz_id") else ""
+                            st.markdown(
+                                f"- **{it.get('title','Untitled')}** · {it.get('subject','General')} · "
+                                f"{it.get('level','')} {tag} · Status: {it.get('status','unknown')}"
+                            )
+                    else:
+                        st.info("No assignments yet.")
+            with d2:
+                rep = _report_text(r, level, avg_pct)
+                st.download_button(
+                    "⬇️ Export",
+                    data=rep,
+                    file_name=f"{str(name).replace(' ','_')}_report.txt",
+                    mime="text/plain",
+                    key=f"dl_{student_id or name}"
+                )
+
+            st.markdown('</div>', unsafe_allow_html=True)

requirements.txt

@@ -0,0 +1,41 @@
+# ---- Core UI ----
+streamlit
+
+# ---- Agent Orchestration / LLM Stack ----
+langgraph
+langchain
+langchain-community
+langchain-openai
+openai
+
+# ---- Database (TiDB via MySQL protocol) ----
+SQLAlchemy
+PyMySQL
+cryptography
+certifi  # SSL CA bundle for TiDB
+
+# ---- Serialization / Hashing (LangGraph deps) ----
+ormsgpack
+xxhash
+
+# ---- Pydantic v2 line (required by langchain-openai/openai) ----
+pydantic
+pydantic-core
+
+# ---- Utilities ----
+tenacity
+requests
+markdownify
+
+# ---- Search (optional tool for your agent) ----
+duckduckgo-search
+bcrypt
+plotly
+
+
+python-dotenv
+requests
+huggingface_hub==0.34.4
+
+# frontend requirements.txt (add this line)
+mysql-connector-python

utils/api.py

@@ -0,0 +1,660 @@
+# utils/api.py
+import os, json, requests
+from urllib3.util.retry import Retry
+from requests.adapters import HTTPAdapter
+
+
+# ---- Setup ----
+BACKEND = (os.getenv("BACKEND_URL") or "").strip().rstrip("/")
+if not BACKEND:
+    # Fail fast at import; Streamlit will surface this in the sidebar on first run
+    raise RuntimeError("BACKEND_URL is not set in Space secrets.")
+
+# Accept either BACKEND_TOKEN or HF_TOKEN
+TOKEN = (os.getenv("BACKEND_TOKEN") or os.getenv("HF_TOKEN") or "").strip()
+
+DEFAULT_TIMEOUT = int(os.getenv("BACKEND_TIMEOUT", "30"))
+
+_session = requests.Session()
+
+# Light retry for transient network/server blips
+retry = Retry(
+    total=3,
+    connect=3,
+    read=3,
+    backoff_factor=0.5,
+    status_forcelist=(429, 500, 502, 503, 504),
+    allowed_methods=frozenset(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+)
+_session.mount("https://", HTTPAdapter(max_retries=retry))
+_session.mount("http://", HTTPAdapter(max_retries=retry))
+
+# Default headers
+_session.headers.update({
+    "Accept": "application/json, */*;q=0.1",
+    "User-Agent": "FinEdu-Frontend/1.0 (+spaces)",
+})
+if TOKEN:
+    _session.headers["Authorization"] = f"Bearer {TOKEN}"
+
+def _json_or_raise(resp: requests.Response):
+    ctype = resp.headers.get("content-type", "")
+    if "application/json" in ctype:
+        return resp.json()
+    # Try to parse anyway; show a helpful error if not JSON
+    try:
+        return resp.json()
+    except Exception:
+        snippet = (resp.text or "")[:300]
+        raise RuntimeError(f"Expected JSON but got {ctype or 'unknown'}:\n{snippet}")
+
+def _req(method: str, path: str, **kw):
+    if not path.startswith("/"):
+        path = "/" + path
+    url = f"{BACKEND}{path}"
+    kw.setdefault("timeout", DEFAULT_TIMEOUT)
+    try:
+        r = _session.request(method, url, **kw)
+        r.raise_for_status()
+    except requests.HTTPError as e:
+        body = ""
+        try:
+            body = r.text[:500]
+        except Exception:
+            pass
+        status = getattr(r, "status_code", "?")
+        # Give nicer hints for common auth misconfigs
+        if status in (401, 403):
+            raise RuntimeError(
+                f"{method} {path} failed [{status}] – auth rejected. "
+                f"Check BACKEND_TOKEN/HF_TOKEN permissions and that the backend Space is private/readable."
+            ) from e
+        raise RuntimeError(f"{method} {path} failed [{status}]: {body}") from e
+    except requests.RequestException as e:
+        raise RuntimeError(f"{method} {path} failed: {e.__class__.__name__}: {e}") from e
+    return r
+
+# ---- Health ----
+def health():
+    # Prefer /health but allow root fallback if you change the backend later
+    try:
+        return _json_or_raise(_req("GET", "/health"))
+    except Exception:
+        # best-effort fallback
+        try:
+            _req("GET", "/")
+            return {"ok": True}
+        except Exception:
+            return {"ok": False}
+        
+#---helpers
+
+# --- Optional API prefix (e.g., "/api" or "/v1")
+API_PREFIX_ENV = (os.getenv("BACKEND_API_PREFIX") or "").strip().rstrip("/")
+
+def _prefixes():
+    # Try configured prefix first, then common fallbacks
+    seen, out = set(), []
+    for p in [API_PREFIX_ENV, "", "/api", "/v1", "/api/v1"]:
+        p = (p or "").strip()
+        p = "" if p == "" else ("/" + p.strip("/"))
+        if p not in seen:
+            out.append(p)
+            seen.add(p)
+    return out
+
+def _try_candidates(method: str, candidates: list[tuple[str, dict]]):
+    """
+    candidates: list of (path, request_kwargs) where path starts with "/" and
+    kwargs may include {'params':..., 'json':...}.
+    Tries multiple prefixes (e.g., "", "/api", "/v1") and returns JSON for first 2xx.
+    Auth errors (401/403) are raised immediately.
+    """
+    tried = []
+    for pref in _prefixes():
+        for path, kw in candidates:
+            url = f"{BACKEND}{pref}{path}"
+            tried.append(f"{method} {url}")
+            try:
+                r = _session.request(method, url, timeout=DEFAULT_TIMEOUT, **kw)
+            except requests.RequestException as e:
+                # transient error: keep trying others
+                continue
+            if r.status_code in (401, 403):
+                snippet = (r.text or "")[:200]
+                raise RuntimeError(f"{method} {path} auth failed [{r.status_code}]: {snippet}")
+            if 200 <= r.status_code < 300:
+                return _json_or_raise(r)
+            # 404/405/etc.: try next candidate
+    raise RuntimeError("No matching endpoint for this operation. Tried:\n- " + "\n- ".join(tried))
+
+
+#--helpers for student_db.py
+def user_stats(student_id: int):
+    return _req("GET", f"/students/{student_id}/stats").json()
+def list_assignments_for_student(student_id: int):
+    return _req("GET", f"/students/{student_id}/assignments").json()
+def student_quiz_average(student_id: int):
+    d = _req("GET", f"/students/{student_id}/quiz_avg").json()
+    # Normalize common shapes: {"avg": 82}, {"score_pct": "82"}, "82", 82
+    if isinstance(d, dict):
+        for k in ("avg", "average", "score_pct", "score", "value"):
+            if k in d:
+                v = d[k]
+                break
+        else:
+            # fallback: first numeric-ish value
+            v = next((vv for vv in d.values() if isinstance(vv, (int, float, str))), 0)
+    else:
+        v = d
+    try:
+        # handle strings like "82" or "82%"
+        return int(round(float(str(v).strip().rstrip("%"))))
+    except Exception:
+        return 0
+def recent_lessons_for_student(student_id: int, limit: int = 5):
+    return _req("GET", f"/students/{student_id}/recent", params={"limit": limit}).json()
+
+# # --- Teacher endpoints (backend Space) ---
+# def create_class(teacher_id: int, name: str):
+#     return _json_or_raise(_req("POST", f"/teachers/{teacher_id}/classes",
+#                                json={"name": name}))
+
+# def teacher_tiles(teacher_id: int):
+#     return _json_or_raise(_req("GET", f"/teachers/{teacher_id}/tiles"))
+
+# def list_classes_by_teacher(teacher_id: int):
+#     return _json_or_raise(_req("GET", f"/teachers/{teacher_id}/classes"))
+
+# def class_student_metrics(class_id: int):
+#     return _json_or_raise(_req("GET", f"/classes/{class_id}/student_metrics"))
+
+# def class_weekly_activity(class_id: int):
+#     return _json_or_raise(_req("GET", f"/classes/{class_id}/weekly_activity"))
+
+# def class_progress_overview(class_id: int):
+#     return _json_or_raise(_req("GET", f"/classes/{class_id}/progress_overview"))
+
+# def class_recent_activity(class_id: int, limit=6, days=30):
+#     return _json_or_raise(_req("GET", f"/classes/{class_id}/recent_activity",
+#                                params={"limit": limit, "days": days}))
+
+# def list_students_in_class(class_id: int):
+#     return _json_or_raise(_req("GET", f"/classes/{class_id}/students"))
+
+# Optional if you want to compute levels server-side
+def level_from_xp(xp: int):
+    return _json_or_raise(_req("GET", "/levels/from_xp", params={"xp": xp}))["level"]
+
+#--teacherlink.py helpers
+def join_class_by_code(student_id: int, code: str):
+    d = _json_or_raise(_req("POST", f"/students/{student_id}/classes/join", json={"code": code}))
+    # backend may return {"class_id": ...} or full class object; both are fine
+    return d.get("class_id", d)
+
+def list_classes_for_student(student_id: int):
+    return _json_or_raise(_req("GET", f"/students/{student_id}/classes"))
+
+def class_content_counts(class_id: int):
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/counts"))
+
+def student_class_progress(student_id: int, class_id: int):
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/students/{student_id}/progress"))
+
+def leave_class(student_id: int, class_id: int):
+    # could also be DELETE /classes/{class_id}/students/{student_id}
+    _json_or_raise(_req("POST", f"/classes/{class_id}/leave", json={"student_id": student_id}))
+    return True
+
+def student_assignments_for_class(student_id: int, class_id: int):
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/students/{student_id}/assignments"))
+
+
+
+
+# ---------- TEACHERS / CLASSES / CONTENT (BACKEND ROUTES THAT EXIST) ----------
+
+# Classes
+def create_class(teacher_id: int, name: str):
+    # Backend has POST /teachers/{teacher_id}/classes with body {name}
+    return _try_candidates("POST", [
+        (f"/teachers/{teacher_id}/classes", {"json": {"name": name}}),
+        # fallbacks if you ever rename:
+        ("/classes", {"json": {"teacher_id": teacher_id, "name": name}}),
+    ])
+
+def list_classes_by_teacher(teacher_id: int):
+    return _try_candidates("GET", [
+        (f"/teachers/{teacher_id}/classes", {}),
+    ])
+
+def list_students_in_class(class_id: int):
+    # exact route in backend
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/students"))
+
+def class_content_counts(class_id: int):
+    return _try_candidates("GET", [
+        (f"/classes/{class_id}/content_counts", {}),
+        (f"/classes/{class_id}/counts", {}),
+    ])
+
+def list_class_assignments(class_id: int):
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/assignments"))
+
+def class_analytics(class_id: int):
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/analytics"))
+
+def teacher_tiles(teacher_id: int):
+    return _json_or_raise(_req("GET", f"/teachers/{teacher_id}/tiles"))
+
+def class_student_metrics(class_id: int):
+    # backend: /classes/{id}/students/metrics
+    return _try_candidates("GET", [
+        (f"/classes/{class_id}/students/metrics", {}),
+        # tolerant fallbacks:
+        (f"/classes/{class_id}/student_metrics", {}),
+        (f"/classes/{class_id}/students", {}),   # older shape (list of students)
+    ])
+
+def class_weekly_activity(class_id: int):
+    # backend: /classes/{id}/activity/weekly
+    return _try_candidates("GET", [
+        (f"/classes/{class_id}/activity/weekly", {}),
+        (f"/classes/{class_id}/weekly_activity", {}),
+    ])
+
+def class_progress_overview(class_id: int):
+    # backend: /classes/{id}/progress
+    return _try_candidates("GET", [
+        (f"/classes/{class_id}/progress", {}),
+        (f"/classes/{class_id}/progress_overview", {}),
+    ])
+
+def class_recent_activity(class_id: int, limit=6, days=30):
+    # backend: /classes/{id}/activity/recent
+    return _try_candidates("GET", [
+        (f"/classes/{class_id}/activity/recent", {"params": {"limit": limit, "days": days}}),
+        (f"/classes/{class_id}/recent_activity", {"params": {"limit": limit, "days": days}}),
+    ])
+
+# Lessons
+def list_lessons_by_teacher(teacher_id: int):
+    return _json_or_raise(_req("GET", f"/teachers/{teacher_id}/lessons"))
+
+def create_lesson(teacher_id: int, title: str, description: str,
+                  subject: str, level: str, sections: list[dict]):
+    payload = {
+        "title": title,
+        "description": description,
+        "subject": subject,
+        "level": level,
+        "sections": sections,
+    }
+    # backend route:
+    d = _try_candidates("POST", [
+        (f"/teachers/{teacher_id}/lessons", {"json": payload}),
+        # fallback if you later add a flat /lessons route:
+        ("/lessons", {"json": {"teacher_id": teacher_id, **payload}}),
+    ])
+    # tolerate both {"lesson_id": N} or full object with id
+    return d.get("lesson_id", d.get("id", d))
+
+def get_lesson(lesson_id: int):
+    return _json_or_raise(_req("GET", f"/lessons/{lesson_id}"))
+
+def update_lesson(lesson_id: int, teacher_id: int, title: str, description: str,
+                  subject: str, level: str, sections: list[dict]):
+    d = _req("PUT", f"/lessons/{lesson_id}", json={
+        "teacher_id": teacher_id,
+        "title": title,
+        "description": description,
+        "subject": subject,
+        "level": level,
+        "sections": sections
+    }).json()
+    return bool(d.get("ok", True))
+
+def delete_lesson(lesson_id: int, teacher_id: int):
+    d = _req("DELETE", f"/lessons/{lesson_id}", json={"teacher_id": teacher_id}).json()
+    return bool(d.get("ok", True)), d.get("message", "")
+
+# Quizzes
+def list_quizzes_by_teacher(teacher_id: int):
+    return _json_or_raise(_req("GET", f"/teachers/{teacher_id}/quizzes"))
+
+def create_quiz(lesson_id: int, title: str, items: list[dict], settings: dict):
+    d = _req("POST", "/quizzes", json={
+        "lesson_id": lesson_id, "title": title, "items": items, "settings": settings
+    }).json()
+    return d.get("quiz_id", d.get("id", d))
+
+# def get_quiz(quiz_id: int):
+#     return _json_or_raise(_req("GET", f"/quizzes/{quiz_id}"))
+
+# def get_quiz(quiz_id: int):
+#     # NEW wrapper that hits GET /quizzes/{quiz_id}
+#     return _req("GET", f"/quizzes/{quiz_id}")
+
+def get_quiz(quiz_id: int):
+    """Fetch a teacher-created quiz (GET /quizzes/{quiz_id}) and return JSON."""
+    return _json_or_raise(_req("GET", f"/quizzes/{quiz_id}"))
+
+def submit_quiz(student_id, assignment_id, quiz_id, score, total, details):
+    payload = {"student_id": student_id, "assignment_id": assignment_id,
+               "quiz_id": quiz_id, "score": score, "total": total, "details": details}
+    return _req("POST", "/quizzes/submit", json=payload)
+
+def update_quiz(quiz_id: int,
+ teacher_id: int, title: str, items: list[dict], settings: dict):
+    d = _req("PUT", f"/quizzes/{quiz_id}", json={
+        "teacher_id": teacher_id, "title": title, "items": items, "settings": settings
+    }).json()
+    return bool(d.get("ok", True))
+
+def delete_quiz(quiz_id: int, teacher_id: int):
+    d = _req("DELETE", f"/quizzes/{quiz_id}", json={"teacher_id": teacher_id}).json()
+    return bool(d.get("ok", True)), d.get("message", "")
+
+def list_assigned_students_for_lesson(lesson_id: int):
+    return _json_or_raise(_req("GET", f"/lessons/{lesson_id}/assignees"))
+
+def list_assigned_students_for_quiz(quiz_id: int):
+    return _json_or_raise(_req("GET", f"/quizzes/{quiz_id}/assignees"))
+
+# Assignments
+def assign_to_class(lesson_id: int | None, quiz_id: int | None, class_id: int, teacher_id: int, due_at: str | None = None):
+    # backend route name is /assign (not /assignments)
+    d = _try_candidates("POST", [
+        ("/assign", {"json": {
+            "lesson_id": lesson_id, "quiz_id": quiz_id,
+            "class_id": class_id, "teacher_id": teacher_id, "due_at": due_at
+        }}),
+        ("/assignments", {"json": {
+            "lesson_id": lesson_id, "quiz_id": quiz_id,
+            "class_id": class_id, "teacher_id": teacher_id, "due_at": due_at
+        }}),
+    ])
+    return bool(d.get("ok", True))
+
+
+
+
+# # ---- Classes / Teacher endpoints (tolerant) ----
+# def create_class(teacher_id: int, name: str):
+#     return _try_candidates("POST", [
+#         (f"/teachers/{teacher_id}/classes",   {"json": {"name": name}}),
+#         (f"/teachers/{teacher_id}/classrooms",{"json": {"name": name}}),
+#         ("/classes",                           {"json": {"teacher_id": teacher_id, "name": name}}),
+#         ("/classrooms",                        {"json": {"teacher_id": teacher_id, "name": name}}),
+#     ])
+
+# def list_classes_by_teacher(teacher_id: int):
+#     return _try_candidates("GET", [
+#         (f"/teachers/{teacher_id}/classes",    {}),
+#         (f"/teachers/{teacher_id}/classrooms", {}),
+#         (f"/classes/by-teacher/{teacher_id}",  {}),
+#         (f"/classrooms/by-teacher/{teacher_id}", {}),
+#         ("/classes",                            {"params": {"teacher_id": teacher_id}}),
+#         ("/classrooms",                         {"params": {"teacher_id": teacher_id}}),
+#     ])
+
+# def list_students_in_class(class_id: int):
+#     return _try_candidates("GET", [
+#         (f"/classes/{class_id}/students",     {}),
+#         (f"/classrooms/{class_id}/students",  {}),
+#         ("/students",                         {"params": {"class_id": class_id}}),
+#     ])
+
+# def class_content_counts(class_id: int):
+#     return _try_candidates("GET", [
+#         (f"/classes/{class_id}/content_counts",    {}),
+#         (f"/classrooms/{class_id}/content_counts", {}),
+#         (f"/classes/{class_id}/counts",            {}),
+#         (f"/classrooms/{class_id}/counts",         {}),
+#     ])
+
+# def list_class_assignments(class_id: int):
+#     return _try_candidates("GET", [
+#         (f"/classes/{class_id}/assignments",     {}),
+#         (f"/classrooms/{class_id}/assignments",  {}),
+#         ("/assignments",                         {"params": {"class_id": class_id}}),
+#     ])
+
+# def class_analytics(class_id: int):
+#     return _try_candidates("GET", [
+#         (f"/classes/{class_id}/analytics",     {}),
+#         (f"/classrooms/{class_id}/analytics",  {}),
+#     ])
+
+
+# #--contentmanage.py helpers
+
+# # ---------- Teacher/content management endpoints (backend Space) ----------
+# def list_classes_by_teacher(teacher_id: int):
+#     return _req("GET", f"/teachers/{teacher_id}/classes").json()
+
+# def list_all_students_for_teacher(teacher_id: int):
+#     return _req("GET", f"/teachers/{teacher_id}/students").json()
+
+# def list_lessons_by_teacher(teacher_id: int):
+#     return _req("GET", f"/teachers/{teacher_id}/lessons").json()
+
+# def list_quizzes_by_teacher(teacher_id: int):
+#     return _req("GET", f"/teachers/{teacher_id}/quizzes").json()
+
+# def create_lesson(teacher_id: int, title: str, description: str, subject: str, level: str, sections: list[dict]):
+#     d = _req("POST", "/lessons", json={
+#         "teacher_id": teacher_id, "title": title, "description": description,
+#         "subject": subject, "level": level, "sections": sections
+#     }).json()
+#     return d["lesson_id"]
+
+# def update_lesson(lesson_id: int, teacher_id: int, title: str, description: str, subject: str, level: str, sections: list[dict]):
+#     d = _req("PUT", f"/lessons/{lesson_id}", json={
+#         "teacher_id": teacher_id, "title": title, "description": description,
+#         "subject": subject, "level": level, "sections": sections
+#     }).json()
+#     return bool(d.get("ok", True))
+
+# def delete_lesson(lesson_id: int, teacher_id: int):
+#     d = _req("DELETE", f"/lessons/{lesson_id}", json={"teacher_id": teacher_id}).json()
+#     return bool(d.get("ok", True)), d.get("message", "")
+
+# def get_lesson(lesson_id: int):
+#     return _req("GET", f"/lessons/{lesson_id}").json()  # {"lesson":{...}, "sections":[...]}
+
+# def create_quiz(lesson_id: int, title: str, items: list[dict], settings: dict):
+#     d = _req("POST", "/quizzes", json={"lesson_id": lesson_id, "title": title, "items": items, "settings": settings}).json()
+#     return d["quiz_id"]
+
+# def update_quiz(quiz_id: int, teacher_id: int, title: str, items: list[dict], settings: dict):
+#     d = _req("PUT", f"/quizzes/{quiz_id}", json={"teacher_id": teacher_id, "title": title, "items": items, "settings": settings}).json()
+#     return bool(d.get("ok", True))
+
+# def delete_quiz(quiz_id: int, teacher_id: int):
+#     d = _req("DELETE", f"/quizzes/{quiz_id}", json={"teacher_id": teacher_id}).json()
+#     return bool(d.get("ok", True)), d.get("message", "")
+
+# def list_assigned_students_for_lesson(lesson_id: int):
+#     return _req("GET", f"/lessons/{lesson_id}/assignees").json()
+
+# def list_assigned_students_for_quiz(quiz_id: int):
+#     return _req("GET", f"/quizzes/{quiz_id}/assignees").json()
+
+# def assign_to_class(lesson_id: int | None, quiz_id: int | None, class_id: int, teacher_id: int):
+#     d = _req("POST", "/assignments", json={
+#         "lesson_id": lesson_id, "quiz_id": quiz_id, "class_id": class_id, "teacher_id": teacher_id
+#     }).json()
+#     return bool(d.get("ok", True))
+
+# #-- studentlist helpers
+
+# def list_classes_by_teacher(teacher_id: int):
+#     return _req("GET", f"/teachers/{teacher_id}/classes").json()
+
+# def get_class(class_id: int):
+#     return _req("GET", f"/classes/{class_id}").json()
+
+# def class_student_metrics(class_id: int):
+#     # expected to return list of rows with fields used in the UI
+#     return _req("GET", f"/classes/{class_id}/students").json()
+
+# def list_assignments_for_student(student_id: int):
+#     return _req("GET", f"/students/{student_id}/assignments").json()
+
+# ---------- LLM-based quiz generation (backend uses GEN_MODEL) ----------
+def generate_quiz_from_text(content: str, n_questions: int = 5, subject: str = "finance", level: str = "beginner"):
+    """
+    Backend should read GEN_MODEL from env and use your chosen model (llama-3.1-8b-instruct).
+    Return shape: {"items":[{"question":...,"options":[...],"answer_key":"A"}]}
+    """
+    return _req("POST", "/quiz/generate", json={
+        "content": content, "n_questions": n_questions, "subject": subject, "level": level
+    }).json()
+
+
+# ---- Legacy agent endpoints (keep) ----
+def start_agent(student_id: int, lesson_id: int, level_slug: str):
+    return _json_or_raise(_req("POST", "/agent/start",
+                               json={"student_id": student_id, "lesson_id": lesson_id, "level_slug": level_slug}))
+
+def get_agent_quiz(student_id: int, lesson_id: int, level_slug: str):
+      d = _json_or_raise(_req("POST", "/agent/quiz",
+                              json={"student_id": student_id, "lesson_id": lesson_id, "level_slug": level_slug}))
+      return d["items"]
+
+def grade_quiz(student_id: int, lesson_id: int, level_slug: str,
+               answers: list[str], assignment_id: int | None = None):
+    d = _json_or_raise(_req("POST", "/agent/grade",
+                            json={"student_id": student_id, "lesson_id": lesson_id, "level_slug": level_slug,
+                                  "answers": answers, "assignment_id": assignment_id}))
+    return d["score"], d["total"]
+
+def next_step(student_id: int, lesson_id: int, level_slug: str,
+              answers: list[str], assignment_id: int | None = None):
+    return _json_or_raise(_req("POST", "/agent/coach_or_celebrate",
+                               json={"student_id": student_id, "lesson_id": lesson_id, "level_slug": level_slug,
+                                     "answers": answers, "assignment_id": assignment_id}))
+
+# ---- Auth ----
+def login(email: str, password: str):
+    return _json_or_raise(_req("POST", "/auth/login", json={"email": email, "password": password}))
+
+def signup_student(name: str, email: str, password: str, level_label: str, country_label: str):
+    payload_student = {
+        "name": name, "email": email, "password": password,
+        "level_label": level_label, "country_label": country_label
+    }
+    # Prefer dedicated route; fall back to /auth/register with role
+    return _try_candidates("POST", [
+        ("/auth/signup/student", {"json": payload_student}),
+        ("/auth/register", {"json": {
+            "role": "student", "name": name, "email": email, "password": password,
+            "level": level_label, "country": country_label
+        }}),
+    ])
+
+def signup_teacher(title: str, name: str, email: str, password: str):
+    payload_teacher = {"title": title, "name": name, "email": email, "password": password}
+    return _try_candidates("POST", [
+        ("/auth/signup/teacher", {"json": payload_teacher}),
+        ("/auth/register", {"json": {
+            "role": "teacher", "title": title, "name": name, "email": email, "password": password
+        }}),
+    ])
+
+# ---- New LangGraph-backed endpoints ----
+def fetch_lesson_content(lesson: str, module: str, topic: str):
+    r = _json_or_raise(_req("POST", "/lesson",
+                            json={"lesson": lesson, "module": module, "topic": topic}))
+    return r["lesson_content"]
+
+def submit_lesson_quiz(lesson: str, module: str, topic: str, responses: dict):
+    return _json_or_raise(_req("POST", "/lesson-quiz",
+                               json={"lesson": lesson, "module": module, "topic": topic, "responses": responses}))
+
+def submit_practice_quiz(lesson: str, responses: dict):
+    return _json_or_raise(_req("POST", "/practice-quiz",
+                               json={"lesson": lesson, "responses": responses}))
+
+def send_to_chatbot(messages: list[dict]):
+    return _json_or_raise(_req("POST", "/chatbot", json={"messages": messages}))
+
+
+# --- Game API helpers ---
+
+def record_money_match_play(user_id: int, target: int, total: int,
+                            elapsed_ms: int, matched: bool, gained_xp: int):
+    payload = {
+        "user_id": user_id, "target": target, "total": total,
+        "elapsed_ms": elapsed_ms, "matched": matched, "gained_xp": gained_xp,
+    }
+    return _try_candidates("POST", [
+        ("/games/money_match/record", {"json": payload}),
+    ])
+
+def record_budget_builder_play(user_id: int, weekly_allowance: int, budget_score: int,
+                               elapsed_ms: int, allocations: list[dict], gained_xp: int | None):
+    payload = {
+        "user_id": user_id,
+        "weekly_allowance": weekly_allowance,
+        "budget_score": budget_score,
+        "elapsed_ms": elapsed_ms,
+        "allocations": allocations,
+        "gained_xp": gained_xp,
+    }
+    return _try_candidates("POST", [
+        ("/games/budget_builder/record", {"json": payload}),
+    ])
+
+
+def record_debt_dilemma_play(user_id: int, loans_cleared: int,
+                             mistakes: int, elapsed_ms: int, gained_xp: int):
+    payload = {
+        "user_id": user_id,
+        "loans_cleared": loans_cleared,
+        "mistakes": mistakes,
+        "elapsed_ms": elapsed_ms,
+        "gained_xp": gained_xp,
+    }
+    return _try_candidates("POST", [
+        ("/games/debt_dilemma/record", {"json": payload}),
+        ("/api/games/debt_dilemma/record", {"json": payload}),
+        ("/api/v1/games/debt_dilemma/record", {"json": payload}),
+    ])
+
+
+def record_profit_puzzler_play(user_id: int, puzzles_solved: int, mistakes: int, elapsed_ms: int, gained_xp: int | None = None):
+    payload = {"user_id": user_id, "puzzles_solved": puzzles_solved, "mistakes": mistakes, "elapsed_ms": elapsed_ms}
+    if gained_xp is not None:
+        payload["gained_xp"] = gained_xp
+    return _try_candidates("POST", [("/games/profit_puzzler/record", {"json": payload})])
+
+
+def generate_quiz(lesson_id: int, level_slug: str, lesson_title: str):
+    r = requests.post(f"{BACKEND}/generate_quiz", json={
+        "lesson_id": lesson_id,
+        "level_slug": level_slug,
+        "lesson_title": lesson_title
+    }, timeout=60)
+    r.raise_for_status()
+    return r.json()["quiz"]
+
+def submit_quiz(lesson_id: int, level_slug: str, user_answers: list[dict], original_quiz: list[dict]):
+    r = requests.post(f"{BACKEND}/submit_quiz", json={
+        "lesson_id": lesson_id,
+        "level_slug": level_slug,
+        "user_answers": user_answers,
+        "original_quiz": original_quiz
+    }, timeout=90)
+    r.raise_for_status()
+    return r.json()
+
+def tutor_explain(lesson_id: int, level_slug: str, wrong: list[dict]):
+    r = requests.post(f"{BACKEND}/tutor/explain", json={
+        "lesson_id": lesson_id,
+        "level_slug": level_slug,
+        "wrong": wrong
+    }, timeout=60)
+    r.raise_for_status()
+    return r.json()["feedback"]

utils/db.py

@@ -0,0 +1,1327 @@
+# utils/db.py (top of file)
+import os
+import json
+import certifi
+from contextlib import contextmanager
+from datetime import date, timedelta
+
+# password hashing
+import bcrypt
+
+# --- Feature flag: DB off by default in frontend Space ---
+DISABLE_DB = os.getenv("DISABLE_DB", "1") == "1"
+
+# Import mysql connector only when DB is enabled
+MYSQL_AVAILABLE = False
+if not DISABLE_DB:
+    try:
+        import mysql.connector  # provided by mysql-connector-python
+        from mysql.connector import Error  # noqa: F401
+        MYSQL_AVAILABLE = True
+    except Exception:
+        MYSQL_AVAILABLE = False  # will raise a friendly error if used
+
+def _db_disabled_error():
+    raise RuntimeError(
+        "Database access is disabled in this frontend (DISABLE_DB=1). "
+        "Route calls through your backend Space instead."
+    )
+
+def get_db_connection():
+    if DISABLE_DB or not MYSQL_AVAILABLE:
+        _db_disabled_error()
+    ssl_enabled = os.getenv("TIDB_ENABLE_SSL", "false").lower() == "true"
+    ssl_ca = certifi.where() if ssl_enabled else None
+    return mysql.connector.connect(
+        host=os.getenv("TIDB_HOST"),
+        port=int(os.getenv("TIDB_PORT", 4000)),
+        user=os.getenv("TIDB_USER"),
+        password=os.getenv("TIDB_PASSWORD"),
+        database=os.getenv("TIDB_DATABASE", "fin_ed_agentic"),
+        ssl_ca=ssl_ca,
+        ssl_verify_cert=ssl_enabled,
+        autocommit=True,
+    )
+
+@contextmanager
+def cursor(dict_rows=True):
+    if DISABLE_DB or not MYSQL_AVAILABLE:
+        _db_disabled_error()
+    conn = get_db_connection()
+    try:
+        cur = conn.cursor(dictionary=dict_rows)
+        yield cur
+        conn.commit()
+    finally:
+        cur.close()
+        conn.close()
+
+
+
+# password hashing
+import bcrypt  
+
+# ----------- label <-> slug mappers for UI selects -----------
+COUNTRY_SLUG = {
+    "Jamaica": "jamaica", "USA": "usa", "UK": "uk",
+    "India": "india", "Canada": "canada", "Other": "other", "N/A": "na"
+}
+LEVEL_SLUG = {
+    "Beginner": "beginner", "Intermediate": "intermediate", "Advanced": "advanced", "N/A": "na"
+}
+ROLE_SLUG = {"Student": "student", "Teacher": "teacher"}
+
+def _slug(s: str) -> str:
+    return (s or "").strip().lower()
+
+def hash_password(plain: str) -> bytes:
+    return bcrypt.hashpw(plain.encode("utf-8"), bcrypt.gensalt())
+
+def verify_password(plain: str, hashed: bytes | None) -> bool:
+    if not plain or not hashed:
+        return False
+    try:
+        return bcrypt.checkpw(plain.encode("utf-8"), hashed)
+    except Exception:
+        return False
+
+def _ensure_na_slugs():
+    """
+    Make sure 'na' exists in countries/levels for teacher rows.
+    Harmless if already present.
+    """
+    with cursor() as cur:
+        cur.execute("INSERT IGNORE INTO countries(slug,label) VALUES('na','N/A')")
+        cur.execute("INSERT IGNORE INTO levels(slug,label) VALUES('na','N/A')")
+ 
+
+# def get_db_connection():
+#     ssl_enabled = os.getenv("TIDB_ENABLE_SSL", "false").lower() == "true"
+#     ssl_ca = certifi.where() if ssl_enabled else None
+#     return mysql.connector.connect(
+#         host=os.getenv("TIDB_HOST"),
+#         port=int(os.getenv("TIDB_PORT", 4000)),
+#         user=os.getenv("TIDB_USER"),
+#         password=os.getenv("TIDB_PASSWORD"),
+#         database=os.getenv("TIDB_DATABASE", "agenticfinance"),
+#         ssl_ca=ssl_ca,
+#         ssl_verify_cert=ssl_enabled,
+#         autocommit=True,
+#     )
+
+@contextmanager
+def cursor(dict_rows=True):
+    conn = get_db_connection()
+    try:
+        cur = conn.cursor(dictionary=dict_rows)
+        yield cur
+        conn.commit()
+    finally:
+        cur.close()
+        conn.close()
+
+# ---------- USERS ----------
+def create_user(name:str, email:str, country:str, level:str, role:str):
+    
+    slug = lambda s: s.strip().lower()
+    with cursor() as cur:
+        cur.execute("""
+        INSERT INTO users(name,email,country_slug,level_slug,role_slug)
+        VALUES (%s,%s,%s,%s,%s)
+        """, (name, email.strip().lower(), slug(country), slug(level), slug(role)))
+    return True
+
+# role-specific creators
+def create_student(*, name:str, email:str, password:str, level_label:str, country_label:str) -> bool:
+    """
+    level_label/country_label are UI labels (e.g., 'Beginner', 'Jamaica').
+    """
+    level_slug = LEVEL_SLUG.get(level_label, _slug(level_label))
+    country_slug = COUNTRY_SLUG.get(country_label, _slug(country_label))
+    with cursor() as cur:
+        cur.execute("""
+        INSERT INTO users (name,email,password_hash,title,country_slug,level_slug,role_slug)
+        VALUES (%s,%s,%s,NULL,%s,%s,'student')
+        """, (name.strip(), email.strip().lower(), hash_password(password), country_slug, level_slug))
+    return True
+
+def create_teacher(*, title:str, name:str, email:str, password:str) -> bool:
+    """
+    Teachers do not provide level/country; we store 'na' for both.
+    """
+    _ensure_na_slugs()
+    with cursor() as cur:
+        cur.execute("""
+        INSERT INTO users (title,name,email,password_hash,country_slug,level_slug,role_slug)
+        VALUES (%s,%s,%s,%s,'na','na','teacher')
+        """, (title.strip(), name.strip(), email.strip().lower(), hash_password(password)))
+    return True
+
+
+def get_user_by_email(email:str):
+    with cursor() as cur:
+        cur.execute("""
+        SELECT 
+          u.user_id, u.title, u.name, u.email, u.password_hash,
+          u.country_slug, c.label AS country,
+          u.level_slug,   l.label AS level,
+          u.role_slug,    r.label AS role
+        FROM users u
+        JOIN countries c ON c.slug = u.country_slug
+        JOIN levels    l ON l.slug = u.level_slug
+        JOIN roles     r ON r.slug = u.role_slug
+        WHERE u.email=%s
+        LIMIT 1
+        """, (email.strip().lower(),))
+        u = cur.fetchone()
+        if not u:
+            return None
+        
+        u["role"] = "Teacher" if u["role_slug"] == "teacher" else "Student"
+        return u
+
+def check_password(email: str, plain_password: str) -> dict | None:
+    """
+    Returns the user dict if password is correct, else None.
+    """
+    user = get_user_by_email(email)
+    if not user:
+        return None
+    if verify_password(plain_password, user.get("password_hash")):
+        return user
+    return None
+
+
+# ---------- CLASSES ----------
+import random, string
+def _code():
+    return "".join(random.choices(string.ascii_uppercase + string.digits, k=6))
+
+def create_class(teacher_id:int, name:str):
+    # ensure unique code
+    for _ in range(20):
+        code = _code()
+        with cursor() as cur:
+            cur.execute("SELECT 1 FROM classes WHERE code=%s", (code,))
+            if not cur.fetchone():
+                cur.execute("INSERT INTO classes(teacher_id,name,code) VALUES(%s,%s,%s)",
+                            (teacher_id, name, code))
+                cur.execute("SELECT LAST_INSERT_ID() AS id")
+                cid = cur.fetchone()["id"]
+                return {"class_id": cid, "code": code}
+    raise RuntimeError("Could not generate unique class code")
+
+
+
+def join_class_by_code(student_id:int, code:str):
+    with cursor() as cur:
+        cur.execute("SELECT class_id FROM classes WHERE code=%s", (code.strip().upper(),))
+        row = cur.fetchone()
+        if not row:
+            raise ValueError("Invalid class code")
+        cur.execute("INSERT IGNORE INTO class_students(class_id,student_id) VALUES(%s,%s)",
+                    (row["class_id"], student_id))
+        return row["class_id"]
+
+def list_students_in_class(class_id:int):
+    with cursor() as cur:
+        cur.execute("""
+        SELECT 
+          u.user_id, u.name, u.email, u.level_slug, 
+          cs.joined_at,          -- <- show true join date
+          u.created_at
+        FROM class_students cs 
+        JOIN users u ON u.user_id = cs.student_id
+        WHERE cs.class_id = %s
+        ORDER BY u.name
+        """, (class_id,))
+        return cur.fetchall()
+
+def class_analytics(class_id:int):
+    """
+    Returns:
+      class_avg   -> 0..1 average quiz score for the class (from v_class_stats)
+      total_xp    -> sum of xp_log.delta for students in this class
+      lessons_completed -> count of completed lesson_progress entries for lessons assigned to this class
+    """
+    out = {"class_avg": 0.0, "total_xp": 0, "lessons_completed": 0}
+
+    with cursor() as cur:
+        # class average from view
+        cur.execute("SELECT class_avg FROM v_class_stats WHERE class_id=%s", (class_id,))
+        row = cur.fetchone()
+        if row:
+            out["class_avg"] = float(row["class_avg"] or 0)
+
+        # total XP for all students in this class
+        cur.execute("""
+        SELECT COALESCE(SUM(x.delta),0) AS total_xp
+        FROM xp_log x
+        JOIN class_students cs ON cs.student_id = x.user_id
+        WHERE cs.class_id = %s
+        """, (class_id,))
+        out["total_xp"] = int((cur.fetchone() or {"total_xp": 0})["total_xp"])
+
+        # lessons completed that were actually assigned to this class
+        cur.execute("""
+        SELECT COUNT(*) AS n
+        FROM lesson_progress lp
+        JOIN class_students cs ON cs.student_id = lp.user_id
+        JOIN assignments a ON a.lesson_id = lp.lesson_id
+        WHERE cs.class_id = %s
+          AND a.class_id = %s
+          AND lp.status = 'completed'
+        """, (class_id, class_id))
+        out["lessons_completed"] = int((cur.fetchone() or {"n": 0})["n"])
+
+    return out
+    
+# ---------- Teacher dash for real time data - Class Helpers  ----------
+def class_content_counts(class_id:int):
+    # counts of distinct lessons and quizzes assigned to this class
+    with cursor() as cur:
+        cur.execute("""
+            SELECT 
+              COUNT(DISTINCT lesson_id) AS lessons,
+              COUNT(DISTINCT quiz_id)   AS quizzes
+            FROM assignments
+            WHERE class_id=%s
+        """, (class_id,))
+        row = cur.fetchone() or {"lessons": 0, "quizzes": 0}
+    return row
+
+def list_class_assignments(class_id:int):
+    with cursor() as cur:
+        cur.execute("""
+            SELECT 
+              a.assignment_id,
+              a.created_at,
+              l.lesson_id, l.title, l.subject, l.level,
+              a.quiz_id
+            FROM assignments a
+            JOIN lessons l ON l.lesson_id = a.lesson_id
+            WHERE a.class_id=%s
+            ORDER BY a.created_at DESC
+        """, (class_id,))
+        return cur.fetchall()
+
+def list_classes_by_teacher(teacher_id:int):
+    with cursor() as cur:
+        cur.execute("""
+            SELECT s.*, c.code
+            FROM v_class_stats s
+            JOIN classes c USING (class_id)
+            WHERE s.teacher_id=%s
+            ORDER BY c.created_at DESC
+        """, (teacher_id,))
+        return cur.fetchall()
+
+def get_class(class_id:int):
+    with cursor() as cur:
+        cur.execute("SELECT class_id, name, code, teacher_id FROM classes WHERE class_id=%s", (class_id,))
+        return cur.fetchone()
+    
+def class_student_metrics(class_id: int):
+    """
+    Returns one row per student in the class with:
+      name, email, joined_at, lessons_completed, total_assigned_lessons,
+      avg_score (0..1), streak_days, total_xp
+    """
+    with cursor() as cur:
+        cur.execute("""
+        /* total assigned lessons for the class */
+        WITH assigned AS (
+          SELECT DISTINCT lesson_id FROM assignments WHERE class_id = %s
+        )
+        SELECT
+          cs.student_id,
+          u.name,
+          u.email,
+          cs.joined_at,
+          /* lessons completed by this student that were assigned to this class */
+          COALESCE(
+            (SELECT COUNT(*) FROM lesson_progress lp
+             WHERE lp.user_id = cs.student_id
+               AND lp.status = 'completed'
+               AND lp.lesson_id IN (SELECT lesson_id FROM assigned)
+            ), 0
+          ) AS lessons_completed,
+          /* total lessons assigned to this class */
+          (SELECT COUNT(*) FROM assigned) AS total_assigned_lessons,
+          /* average quiz score only for submissions tied to this class */
+          COALESCE(sc.avg_score, 0) AS avg_score,
+          /* streak days from streaks table */
+          COALESCE(str.days, 0) AS streak_days,
+          /* total XP across the app */
+          COALESCE(xp.total_xp, 0) AS total_xp
+        FROM class_students cs
+        JOIN users u ON u.user_id = cs.student_id
+        LEFT JOIN (
+          SELECT s.student_id, AVG(s.score * 1.0 / NULLIF(s.total,0)) AS avg_score
+          FROM submissions s
+          JOIN assignments a ON a.assignment_id = s.assignment_id
+          WHERE a.class_id = %s
+          GROUP BY s.student_id
+        ) sc ON sc.student_id = cs.student_id
+        LEFT JOIN streaks str ON str.user_id = cs.student_id
+        LEFT JOIN (SELECT user_id, SUM(delta) AS total_xp FROM xp_log GROUP BY user_id) xp
+               ON xp.user_id = cs.student_id
+        WHERE cs.class_id = %s
+        ORDER BY u.name;
+        """, (class_id, class_id, class_id))
+        return cur.fetchall()
+
+def level_from_xp(total_xp: int) -> int:
+    try:
+        xp = int(total_xp or 0)
+    except Exception:
+        xp = 0
+    return 1 + xp // 500
+
+
+def list_classes_for_student(student_id: int):
+    with cursor() as cur:
+        cur.execute("""
+            SELECT c.class_id, c.name, c.code, c.teacher_id,
+                   t.name AS teacher_name, cs.joined_at
+            FROM class_students cs
+            JOIN classes c ON c.class_id = cs.class_id
+            JOIN users   t ON t.user_id = c.teacher_id
+            WHERE cs.student_id = %s
+            ORDER BY cs.joined_at DESC
+        """, (student_id,))
+        return cur.fetchall()
+
+def leave_class(student_id: int, class_id: int):
+    with cursor() as cur:
+        cur.execute("DELETE FROM class_students WHERE student_id=%s AND class_id=%s",
+                    (student_id, class_id))
+    return True
+
+def student_class_progress(student_id: int, class_id: int):
+    """
+    Per-student view of progress inside ONE class.
+    Returns: dict(overall_progress 0..1, lessons_completed int,
+                  total_assigned_lessons int, avg_score 0..1)
+    """
+    with cursor() as cur:
+        # total distinct lessons assigned to this class
+        cur.execute("SELECT COUNT(DISTINCT lesson_id) AS n FROM assignments WHERE class_id=%s",
+                    (class_id,))
+        total_assigned = int((cur.fetchone() or {"n": 0})["n"])
+
+        # lessons completed among the class's assigned lessons
+        cur.execute("""
+          WITH assigned AS (SELECT DISTINCT lesson_id FROM assignments WHERE class_id = %s)
+          SELECT COUNT(*) AS n
+          FROM lesson_progress lp
+          WHERE lp.user_id = %s
+            AND lp.status = 'completed'
+            AND lp.lesson_id IN (SELECT lesson_id FROM assigned)
+        """, (class_id, student_id))
+        completed = int((cur.fetchone() or {"n": 0})["n"])
+
+        # student’s avg quiz score but only for submissions tied to this class
+        cur.execute("""
+          SELECT AVG(s.score * 1.0 / NULLIF(s.total,0)) AS avg_ratio
+          FROM submissions s
+          JOIN assignments a ON a.assignment_id = s.assignment_id
+          WHERE a.class_id = %s AND s.student_id = %s
+        """, (class_id, student_id))
+        avg_score = float((cur.fetchone() or {"avg_ratio": 0.0})["avg_ratio"] or 0.0)
+
+    overall = (completed / float(total_assigned)) if total_assigned else 0.0
+    return dict(
+        overall_progress=overall,
+        lessons_completed=completed,
+        total_assigned_lessons=total_assigned,
+        avg_score=avg_score
+    )
+
+def student_assignments_for_class(student_id: int, class_id: int):
+    """
+    All assignments in a class, annotated with THIS student's status/progress
+    and (if applicable) their quiz score for that assignment.
+    Deduplicates by lesson_id (keeps the most recent assignment per lesson).
+    """
+    with cursor() as cur:
+        cur.execute("""
+          SELECT
+            a.assignment_id, a.lesson_id, l.title, l.subject, l.level,
+            a.quiz_id, a.due_at,
+            COALESCE(lp.status,'not_started') AS status,
+            lp.current_pos,
+            /* student's latest submission on this assignment (if any) */
+            (SELECT MAX(s.submitted_at) FROM submissions s
+              WHERE s.assignment_id = a.assignment_id AND s.student_id = %s) AS last_submit_at,
+            (SELECT s2.score FROM submissions s2
+              WHERE s2.assignment_id = a.assignment_id AND s2.student_id = %s
+              ORDER BY s2.submitted_at DESC LIMIT 1) AS score,
+            (SELECT s3.total FROM submissions s3
+              WHERE s3.assignment_id = a.assignment_id AND s3.student_id = %s
+              ORDER BY s3.submitted_at DESC LIMIT 1) AS total
+          FROM (
+            SELECT
+              a.*,
+              ROW_NUMBER() OVER (
+                PARTITION BY a.lesson_id
+                ORDER BY a.created_at DESC, a.assignment_id DESC
+              ) AS rn
+            FROM assignments a
+            WHERE a.class_id = %s
+          ) AS a
+          JOIN lessons l ON l.lesson_id = a.lesson_id
+          LEFT JOIN lesson_progress lp
+                 ON lp.user_id = %s AND lp.lesson_id = a.lesson_id
+          WHERE a.rn = 1
+          ORDER BY a.created_at DESC
+        """, (student_id, student_id, student_id, class_id, student_id))
+        return cur.fetchall()
+
+
+    
+
+def update_quiz(quiz_id:int, teacher_id:int, title:str, items:list[dict], settings:dict|None=None) -> bool:
+    with cursor() as cur:
+        # only the teacher who owns the linked lesson can edit
+        cur.execute("""
+            SELECT 1
+            FROM quizzes q
+            JOIN lessons l ON l.lesson_id = q.lesson_id
+            WHERE q.quiz_id = %s AND l.teacher_id = %s
+            LIMIT 1
+        """, (quiz_id, teacher_id))
+        if not cur.fetchone():
+            return False
+
+        cur.execute("UPDATE quizzes SET title=%s, settings=%s WHERE quiz_id=%s",
+                    (title, json.dumps(settings or {}), quiz_id))
+
+        cur.execute("DELETE FROM quiz_items WHERE quiz_id=%s", (quiz_id,))
+        for i, it in enumerate(items, start=1):
+            cur.execute("""
+                INSERT INTO quiz_items(quiz_id, position, question, options, answer_key, points)
+                VALUES (%s, %s, %s, %s, %s, %s)
+            """, (
+                quiz_id, i,
+                it["question"],
+                json.dumps(it.get("options", [])),
+                json.dumps(it.get("answer_key")),  # single letter as JSON string
+                int(it.get("points", 1))
+            ))
+    return True
+
+
+def class_weekly_activity(class_id:int):
+    start = date.today() - timedelta(days=6)
+    with cursor() as cur:
+        cur.execute("""
+            SELECT DATE(lp.last_accessed) d, COUNT(*) n
+            FROM lesson_progress lp
+            JOIN class_students cs ON cs.student_id = lp.user_id
+            WHERE cs.class_id=%s AND lp.last_accessed >= %s
+            GROUP BY DATE(lp.last_accessed)
+        """, (class_id, start))
+        lessons = {r["d"]: r["n"] for r in cur.fetchall()}
+
+        cur.execute("""
+            SELECT DATE(s.submitted_at) d, COUNT(*) n
+            FROM submissions s
+            JOIN assignments a ON a.assignment_id = s.assignment_id
+            WHERE a.class_id=%s AND s.submitted_at >= %s
+            GROUP BY DATE(s.submitted_at)
+        """, (class_id, start))
+        quizzes = {r["d"]: r["n"] for r in cur.fetchall()}
+
+        cur.execute("""
+            SELECT DATE(g.started_at) d, COUNT(*) n
+            FROM game_sessions g
+            JOIN class_students cs ON cs.student_id = g.user_id
+            WHERE cs.class_id=%s AND g.started_at >= %s
+            GROUP BY DATE(g.started_at)
+        """, (class_id, start))
+        games = {r["d"]: r["n"] for r in cur.fetchall()}
+
+    out = []
+    for i in range(7):
+        d = start + timedelta(days=i)
+        out.append({
+            "date": d,
+            "lessons": lessons.get(d, 0),
+            "quizzes": quizzes.get(d, 0),
+            "games": games.get(d, 0),
+        })
+    return out
+
+
+
+
+def update_lesson(lesson_id:int, teacher_id:int, title:str, description:str, subject:str, level_slug:str, sections:list[dict]) -> bool:
+    with cursor() as cur:
+        # ownership check
+        cur.execute("SELECT 1 FROM lessons WHERE lesson_id=%s AND teacher_id=%s", (lesson_id, teacher_id))
+        if not cur.fetchone():
+            return False
+
+        cur.execute("""
+          UPDATE lessons
+          SET title=%s, description=%s, subject=%s, level=%s
+          WHERE lesson_id=%s AND teacher_id=%s
+        """, (title, description, subject, level_slug, lesson_id, teacher_id))
+
+        # simplest and safest: rebuild sections in order
+        cur.execute("DELETE FROM lesson_sections WHERE lesson_id=%s", (lesson_id,))
+        for i, sec in enumerate(sections, start=1):
+            cur.execute("""
+              INSERT INTO lesson_sections(lesson_id,position,title,content)
+              VALUES(%s,%s,%s,%s)
+            """, (lesson_id, i, sec.get("title"), sec.get("content")))
+    return True
+
+
+# --- Class progress overview (overall progress, quiz performance, totals)
+def class_progress_overview(class_id: int):
+    """
+    Returns:
+      {
+        "overall_progress": 0..1,
+        "quiz_performance": 0..1,
+        "lessons_completed": int,
+        "class_xp": int
+      }
+    """
+    with cursor() as cur:
+        # total distinct lessons assigned to this class
+        cur.execute("SELECT COUNT(DISTINCT lesson_id) AS n FROM assignments WHERE class_id=%s", (class_id,))
+        total_assigned = int((cur.fetchone() or {"n": 0})["n"])
+
+        # number of enrolled students
+        cur.execute("SELECT COUNT(*) AS n FROM class_students WHERE class_id=%s", (class_id,))
+        num_students = int((cur.fetchone() or {"n": 0})["n"])
+
+        # sum of completed lessons by all students (for assigned lessons)
+        cur.execute("""
+            WITH assigned AS (
+              SELECT DISTINCT lesson_id FROM assignments WHERE class_id = %s
+            ), enrolled AS (
+              SELECT student_id FROM class_students WHERE class_id = %s
+            ), per_student AS (
+              SELECT e.student_id,
+                     COUNT(DISTINCT CASE
+                       WHEN lp.status='completed' AND lp.lesson_id IN (SELECT lesson_id FROM assigned)
+                       THEN lp.lesson_id END) AS completed
+              FROM enrolled e
+              LEFT JOIN lesson_progress lp ON lp.user_id = e.student_id
+              GROUP BY e.student_id
+            )
+            SELECT COALESCE(SUM(completed),0) AS total_completed
+            FROM per_student
+        """, (class_id, class_id))
+        total_completed = int((cur.fetchone() or {"total_completed": 0})["total_completed"] or 0)
+
+        # quiz performance: average percentage for submissions tied to this class
+        cur.execute("""
+            SELECT AVG(s.score * 1.0 / NULLIF(s.total,0)) AS avg_ratio
+            FROM submissions s
+            JOIN assignments a ON a.assignment_id = s.assignment_id
+            WHERE a.class_id = %s
+        """, (class_id,))
+        quiz_perf_row = cur.fetchone() or {"avg_ratio": 0}
+        quiz_perf = float(quiz_perf_row["avg_ratio"] or 0)
+
+        # total class XP (sum of xp for enrolled students)
+        cur.execute("""
+            SELECT COALESCE(SUM(x.delta),0) AS xp
+            FROM xp_log x
+            WHERE x.user_id IN (SELECT student_id FROM class_students WHERE class_id=%s)
+        """, (class_id,))
+        class_xp = int((cur.fetchone() or {"xp": 0})["xp"] or 0)
+
+    if total_assigned and num_students:
+        denominator = float(total_assigned * num_students)
+        overall = float(total_completed) / denominator
+    else:
+        overall = 0.0
+
+    return dict(
+        overall_progress=float(overall),
+        quiz_performance=float(quiz_perf),
+        lessons_completed=int(total_completed),
+        class_xp=int(class_xp),
+    )
+
+# --- Recent student activity with total_xp for level badge
+def class_recent_activity(class_id:int, limit:int=6, days:int=30):
+    """
+    Returns latest activity rows with fields:
+      ts, kind('lesson'|'quiz'|'game'), student_id, student_name, item_title, extra, total_xp
+    """
+    with cursor() as cur:
+        cur.execute(f"""
+            WITH enrolled AS (
+              SELECT student_id FROM class_students WHERE class_id = %s
+            ),
+            xp AS (
+              SELECT user_id, COALESCE(SUM(delta),0) AS total_xp
+              FROM xp_log GROUP BY user_id
+            )
+            SELECT * FROM (
+              /* completed lessons */
+              SELECT lp.last_accessed AS ts,
+                     'lesson'         AS kind,
+                     u.user_id        AS student_id,
+                     u.name           AS student_name,
+                     l.title          AS item_title,
+                     NULL             AS extra,
+                     COALESCE(xp.total_xp,0) AS total_xp
+              FROM lesson_progress lp
+              JOIN enrolled e ON e.student_id = lp.user_id
+              JOIN users u ON u.user_id = lp.user_id
+              JOIN lessons l ON l.lesson_id = lp.lesson_id
+              LEFT JOIN xp ON xp.user_id = u.user_id
+              WHERE lp.status = 'completed' AND lp.last_accessed >= NOW() - INTERVAL {days} DAY
+
+              UNION ALL
+
+              /* quiz submissions */
+              SELECT s.submitted_at AS ts,
+                     'quiz'          AS kind,
+                     u.user_id       AS student_id,
+                     u.name          AS student_name,
+                     l.title         AS item_title,
+                     CONCAT(ROUND(s.score*100.0/NULLIF(s.total,0)),'%') AS extra,
+                     COALESCE(xp.total_xp,0) AS total_xp
+              FROM submissions s
+              JOIN assignments a ON a.assignment_id = s.assignment_id AND a.class_id = %s
+              JOIN users u ON u.user_id = s.student_id
+              JOIN lessons l ON l.lesson_id = a.lesson_id
+              LEFT JOIN xp ON xp.user_id = u.user_id
+              WHERE s.submitted_at >= NOW() - INTERVAL {days} DAY
+
+              UNION ALL
+
+              /* games */
+              SELECT g.started_at AS ts,
+                     'game'        AS kind,
+                     u.user_id     AS student_id,
+                     u.name        AS student_name,
+                     g.game_slug   AS item_title,
+                     NULL          AS extra,
+                     COALESCE(xp.total_xp,0) AS total_xp
+              FROM game_sessions g
+              JOIN enrolled e ON e.student_id = g.user_id
+              JOIN users u ON u.user_id = g.user_id
+              LEFT JOIN xp ON xp.user_id = u.user_id
+              WHERE g.started_at >= NOW() - INTERVAL {days} DAY
+            ) x
+            ORDER BY ts DESC
+            LIMIT %s
+        """, (class_id, class_id, limit))
+        return cur.fetchall()
+
+
+
+def list_quizzes_by_teacher(teacher_id:int):
+    with cursor() as cur:
+        cur.execute("""
+            SELECT q.quiz_id, q.title, q.created_at,
+                   l.title AS lesson_title,
+                   (SELECT COUNT(*) FROM quiz_items qi WHERE qi.quiz_id=q.quiz_id) AS num_items
+            FROM quizzes q
+            JOIN lessons l ON l.lesson_id=q.lesson_id
+            WHERE l.teacher_id=%s
+            ORDER BY q.created_at DESC
+        """, (teacher_id,))
+        return cur.fetchall()
+
+def list_all_students_for_teacher(teacher_id:int):
+    with cursor() as cur:
+        cur.execute("""
+            SELECT DISTINCT u.user_id, u.name, u.email
+            FROM classes c
+            JOIN class_students cs ON cs.class_id=c.class_id
+            JOIN users u ON u.user_id=cs.student_id
+            WHERE c.teacher_id=%s
+            ORDER BY u.name
+        """, (teacher_id,))
+        return cur.fetchall()
+
+# ----- ASSIGNEES (students) -----
+
+def list_assigned_students_for_lesson(lesson_id:int):
+    with cursor() as cur:
+        cur.execute("""
+            WITH direct AS (
+              SELECT student_id FROM assignments
+              WHERE lesson_id=%s AND student_id IS NOT NULL
+            ),
+            via_class AS (
+              SELECT cs.student_id
+              FROM assignments a
+              JOIN class_students cs ON cs.class_id=a.class_id
+              WHERE a.lesson_id=%s AND a.class_id IS NOT NULL
+            ),
+            all_students AS (
+              SELECT student_id FROM direct
+              UNION
+              SELECT student_id FROM via_class
+            )
+            SELECT u.user_id, u.name, u.email
+            FROM users u
+            JOIN all_students s ON s.student_id=u.user_id
+            ORDER BY u.name
+        """, (lesson_id, lesson_id))
+        return cur.fetchall()
+
+def list_assigned_students_for_quiz(quiz_id:int):
+    with cursor() as cur:
+        cur.execute("""
+            WITH direct AS (
+              SELECT student_id FROM assignments
+              WHERE quiz_id=%s AND student_id IS NOT NULL
+            ),
+            via_class AS (
+              SELECT cs.student_id
+              FROM assignments a
+              JOIN class_students cs ON cs.class_id=a.class_id
+              WHERE a.quiz_id=%s AND a.class_id IS NOT NULL
+            ),
+            all_students AS (
+              SELECT student_id FROM direct
+              UNION
+              SELECT student_id FROM via_class
+            )
+            SELECT u.user_id, u.name, u.email
+            FROM users u
+            JOIN all_students s ON s.student_id=u.user_id
+            ORDER BY u.name
+        """, (quiz_id, quiz_id))
+        return cur.fetchall()
+
+# ----- ASSIGN ACTIONS -----
+
+def assign_lesson_to_students(lesson_id:int, student_ids:list[int], teacher_id:int, due_at:str|None=None):
+    # bulk insert; quiz_id stays NULL
+    with cursor() as cur:
+        for sid in student_ids:
+            cur.execute("""
+              INSERT INTO assignments(lesson_id, quiz_id, student_id, assigned_by, due_at)
+              VALUES(%s, NULL, %s, %s, %s)
+              ON DUPLICATE KEY UPDATE due_at=VALUES(due_at)
+            """, (lesson_id, sid, teacher_id, due_at))
+    return True
+
+def assign_quiz_to_students(quiz_id:int, student_ids:list[int], teacher_id:int, due_at:str|None=None):
+    # get lesson_id for integrity
+    with cursor() as cur:
+        cur.execute("SELECT lesson_id FROM quizzes WHERE quiz_id=%s", (quiz_id,))
+        row = cur.fetchone()
+        if not row:
+            raise ValueError("Quiz not found")
+        lesson_id = row["lesson_id"]
+        for sid in student_ids:
+            cur.execute("""
+              INSERT INTO assignments(lesson_id, quiz_id, student_id, assigned_by, due_at)
+              VALUES(%s, %s, %s, %s, %s)
+              ON DUPLICATE KEY UPDATE due_at=VALUES(due_at)
+            """, (lesson_id, quiz_id, sid, teacher_id, due_at))
+    return True
+
+# ----- SAFE DELETE -----
+
+def delete_lesson(lesson_id:int, teacher_id:int):
+    with cursor() as cur:
+        # ownership check
+        cur.execute("SELECT 1 FROM lessons WHERE lesson_id=%s AND teacher_id=%s", (lesson_id, teacher_id))
+        if not cur.fetchone():
+            return False, "You can only delete  own lesson."
+        # block if assigned or quizzed
+        cur.execute("SELECT COUNT(*) AS n FROM assignments WHERE lesson_id=%s", (lesson_id,))
+        if cur.fetchone()["n"] > 0:
+            return False, "Remove assignments first."
+        cur.execute("SELECT COUNT(*) AS n FROM quizzes WHERE lesson_id=%s", (lesson_id,))
+        if cur.fetchone()["n"] > 0:
+            return False, "Delete quizzes for this lesson first."
+        # delete sections then lesson
+        cur.execute("DELETE FROM lesson_sections WHERE lesson_id=%s", (lesson_id,))
+        cur.execute("DELETE FROM lessons WHERE lesson_id=%s AND teacher_id=%s", (lesson_id, teacher_id))
+        return True, "Deleted."
+
+def delete_quiz(quiz_id:int, teacher_id:int):
+    with cursor() as cur:
+        cur.execute("""
+            SELECT 1
+            FROM quizzes q JOIN lessons l ON l.lesson_id=q.lesson_id
+            WHERE q.quiz_id=%s AND l.teacher_id=%s
+        """, (quiz_id, teacher_id))
+        if not cur.fetchone():
+            return False, "You can only delete  own quiz."
+        cur.execute("SELECT COUNT(*) AS n FROM submissions WHERE quiz_id=%s", (quiz_id,))
+        if cur.fetchone()["n"] > 0:
+            return False, "This quiz has submissions. Deleting is blocked."
+        cur.execute("DELETE FROM quiz_items WHERE quiz_id=%s", (quiz_id,))
+        cur.execute("DELETE FROM assignments WHERE quiz_id=%s", (quiz_id,))  
+        cur.execute("DELETE FROM quizzes WHERE quiz_id=%s", (quiz_id,))
+        return True, "Deleted."
+    
+
+def _bump_game_stats(user_id:int, slug:str, *, gained_xp:int, matched:int|None=None, level_inc:int=0):
+    with cursor() as cur:
+        cur.execute("""
+            INSERT INTO game_stats(user_id,game_slug,total_xp,matches,level)
+            VALUES(%s,%s,%s,%s,%s)
+            ON DUPLICATE KEY UPDATE
+              total_xp = total_xp + VALUES(total_xp),
+              matches  = matches + VALUES(matches),
+              level    = GREATEST(level, VALUES(level))
+        """, (user_id, slug, int(gained_xp), int(matched or 1), level_inc))    
+
+# ---------- LESSONS ----------
+def create_lesson(teacher_id:int, title:str, description:str, subject:str, level_slug:str, sections:list[dict]):
+    with cursor() as cur:
+        cur.execute("""
+          INSERT INTO lessons(teacher_id,title,description,subject,level,duration_min)
+          VALUES(%s,%s,%s,%s,%s,%s)
+        """, (teacher_id, title, description, subject, level_slug, 60))
+        cur.execute("SELECT LAST_INSERT_ID() AS id")
+        lesson_id = cur.fetchone()["id"]
+        for i, sec in enumerate(sections, start=1):
+            cur.execute("""
+              INSERT INTO lesson_sections(lesson_id,position,title,content)
+              VALUES(%s,%s,%s,%s)
+            """, (lesson_id, i, sec.get("title"), sec.get("content")))
+    return lesson_id
+
+def list_lessons_by_teacher(teacher_id:int):
+    with cursor() as cur:
+        cur.execute("SELECT * FROM lessons WHERE teacher_id=%s ORDER BY created_at DESC", (teacher_id,))
+        return cur.fetchall()
+
+def get_lesson(lesson_id:int):
+    with cursor() as cur:
+        cur.execute("SELECT * FROM lessons WHERE lesson_id=%s", (lesson_id,))
+        lesson = cur.fetchone()
+        cur.execute("SELECT * FROM lesson_sections WHERE lesson_id=%s ORDER BY position", (lesson_id,))
+        sections = cur.fetchall()
+    return {"lesson": lesson, "sections": sections}
+
+# ---------- QUIZZES ----------
+def create_quiz(lesson_id:int, title:str, items:list[dict], settings:dict|None=None):
+    with cursor() as cur:
+        cur.execute("INSERT INTO quizzes(lesson_id,title,settings) VALUES(%s,%s,%s)",
+                    (lesson_id, title, json.dumps(settings or {})))
+        cur.execute("SELECT LAST_INSERT_ID() AS id")
+        quiz_id = cur.fetchone()["id"]
+        for i, it in enumerate(items, start=1):
+            cur.execute("""
+            INSERT INTO quiz_items(quiz_id,position,question,options,answer_key,points)
+            VALUES(%s,%s,%s,%s,%s,%s)
+            """, (quiz_id, i, it["question"], json.dumps(it.get("options", [])),
+                  json.dumps(it.get("answer_key")), int(it.get("points", 1))))
+    return quiz_id
+
+def get_quiz(quiz_id:int):
+    with cursor() as cur:
+        cur.execute("SELECT * FROM quizzes WHERE quiz_id=%s", (quiz_id,))
+        quiz = cur.fetchone()
+        cur.execute("SELECT * FROM quiz_items WHERE quiz_id=%s ORDER BY position", (quiz_id,))
+        items = cur.fetchall()
+    return {"quiz": quiz, "items": items}
+
+# ---------- ASSIGNMENTS ----------
+def assign_to_class(lesson_id:int, quiz_id:int|None, class_id:int, teacher_id:int, due_at:str|None=None):
+    with cursor() as cur:
+        cur.execute("""
+          INSERT INTO assignments(lesson_id,quiz_id,class_id,assigned_by,due_at)
+          VALUES(%s,%s,%s,%s,%s)
+        """, (lesson_id, quiz_id, class_id, teacher_id, due_at))
+        cur.execute("SELECT LAST_INSERT_ID() AS id")
+        return cur.fetchone()["id"]
+
+def assign_to_student(lesson_id:int, quiz_id:int|None, student_id:int, teacher_id:int, due_at:str|None=None):
+    with cursor() as cur:
+        cur.execute("""
+          INSERT INTO assignments(lesson_id,quiz_id,student_id,assigned_by,due_at)
+          VALUES(%s,%s,%s,%s,%s)
+        """, (lesson_id, quiz_id, student_id, teacher_id, due_at))
+        cur.execute("SELECT LAST_INSERT_ID() AS id")
+        return cur.fetchone()["id"]
+
+def list_assignments_for_student(student_id:int):
+    with cursor() as cur:
+        cur.execute("""
+        SELECT
+            a.assignment_id, a.lesson_id, l.title, l.subject, l.level,
+            a.quiz_id, a.due_at,
+            COALESCE(lp.status,'not_started') AS status,
+            lp.current_pos
+        FROM (
+            SELECT
+                a.*,
+                ROW_NUMBER() OVER (
+                    PARTITION BY a.lesson_id
+                    ORDER BY a.created_at DESC, a.assignment_id DESC
+                ) AS rn
+            FROM assignments a
+            WHERE a.student_id = %s
+               OR a.class_id IN (SELECT class_id FROM class_students WHERE student_id = %s)
+        ) AS a
+        JOIN lessons l ON l.lesson_id = a.lesson_id
+        LEFT JOIN lesson_progress lp
+               ON lp.user_id = %s AND lp.lesson_id = a.lesson_id
+        WHERE a.rn = 1
+        ORDER BY a.created_at DESC
+        """, (student_id, student_id, student_id))
+        return cur.fetchall()
+
+
+# ---------- PROGRESS and SUBMISSIONS ----------
+def save_progress(user_id:int, lesson_id:int, current_pos:int, status:str):
+    with cursor() as cur:
+        cur.execute("""
+        INSERT INTO lesson_progress(user_id,lesson_id,current_pos,status)
+        VALUES(%s,%s,%s,%s)
+        ON DUPLICATE KEY UPDATE current_pos=VALUES(current_pos), status=VALUES(status)
+        """, (user_id, lesson_id, current_pos, status))
+    return True
+
+def submit_quiz(student_id:int, assignment_id:int, quiz_id:int, score:int, total:int, details:dict):
+    with cursor() as cur:
+        cur.execute("""
+        INSERT INTO submissions(assignment_id,quiz_id,student_id,score,total,details)
+        VALUES(%s,%s,%s,%s,%s,%s)
+        ON DUPLICATE KEY UPDATE score=VALUES(score), total=VALUES(total), details=VALUES(details), submitted_at=CURRENT_TIMESTAMP
+        """, (assignment_id, quiz_id, student_id, score, total, json.dumps(details)))
+    
+    return True
+
+# ---------- DASHBOARD SHORTCUTS ----------
+def teacher_tiles(teacher_id:int):
+    with cursor() as cur:
+        cur.execute("SELECT * FROM v_class_stats WHERE teacher_id=%s", (teacher_id,))
+        rows = cur.fetchall()
+    total_students = sum(r["total_students"] for r in rows)
+    lessons_created = _count_lessons(teacher_id)
+    # use simple averages; adjust later as needed
+    class_avg = round(sum(r["class_avg"] for r in rows)/len(rows), 2) if rows else 0
+    active_students = sum(1 for r in rows if r.get("recent_submissions",0) > 0)
+    return dict(total_students=total_students, class_avg=class_avg, lessons_created=lessons_created, active_students=active_students)
+
+def _count_lessons(teacher_id:int):
+    with cursor() as cur:
+        cur.execute("SELECT COUNT(*) AS n FROM lessons WHERE teacher_id=%s", (teacher_id,))
+        return cur.fetchone()["n"]
+
+
+# --- XP and streak helpers ---
+def user_xp_and_level(user_id: int, base: int = 500):
+    with cursor() as cur:
+        cur.execute("SELECT COALESCE(SUM(delta),0) AS xp FROM xp_log WHERE user_id=%s", (user_id,))
+        xp = int((cur.fetchone() or {"xp": 0})["xp"])
+        cur.execute("SELECT COALESCE(days,0) AS days FROM streaks WHERE user_id=%s", (user_id,))
+        streak = int((cur.fetchone() or {"days": 0})["days"])
+
+    # level math
+    level = max(1, xp // base + 1)
+    start_of_level = (level - 1) * base
+    into = xp - start_of_level
+    need = base
+    # exact boundary should flip level and reset progress
+    if into == need:
+        level += 1
+        into = 0
+
+    return {
+        "xp": xp,          # lifetime XP from the DB
+        "level": level,    # current level
+        "into": into,      # XP inside this level
+        "need": need,      # XP needed to reach next level
+        "streak": streak,
+    }
+
+def recent_lessons_for_student(user_id:int, limit:int=5):
+    with cursor() as cur:
+        cur.execute("""
+            SELECT l.title, 
+                   CASE WHEN lp.status='completed' THEN 100
+                        WHEN lp.current_pos IS NULL THEN 0 
+                        ELSE LEAST(95, lp.current_pos * 10) 
+                   END AS progress
+            FROM lessons l
+            LEFT JOIN lesson_progress lp
+              ON lp.lesson_id=l.lesson_id AND lp.user_id=%s
+            WHERE l.lesson_id IN (
+                SELECT lesson_id FROM assignments 
+                WHERE student_id=%s
+                   OR class_id IN (SELECT class_id FROM class_students WHERE student_id=%s)
+            )
+            ORDER BY l.created_at DESC
+            LIMIT %s
+        """, (user_id, user_id, user_id, limit))
+        return cur.fetchall()
+
+def student_quiz_average(student_id: int) -> int:
+    """
+    Returns the student's average quiz percentage (0–100) using the latest
+    submission per quiz from the `submissions` table.
+    """
+    with cursor() as cur:
+        cur.execute("""
+            WITH latest AS (
+              SELECT quiz_id, MAX(submitted_at) AS last_ts
+              FROM submissions
+              WHERE student_id = %s
+              GROUP BY quiz_id
+            )
+            SELECT ROUND(AVG(s.score * 100.0 / NULLIF(s.total,0))) AS pct
+            FROM latest t
+            JOIN submissions s
+              ON s.quiz_id = t.quiz_id
+             AND s.submitted_at = t.last_ts
+            WHERE s.student_id = %s
+        """, (student_id, student_id))
+        row = cur.fetchone() or {}
+    return int(row.get("pct") or 0)
+
+# --- Generic XP bump and streak touch ---
+def add_xp(user_id:int, delta:int, source:str, meta:dict|None=None):
+    with cursor() as cur:
+        cur.execute(
+            "INSERT INTO xp_log(user_id,source,delta,meta) VALUES(%s,%s,%s,%s)",
+            (user_id, source, int(delta), json.dumps(meta or {}))
+        )
+        # streak touch
+        cur.execute("SELECT days, last_active FROM streaks WHERE user_id=%s", (user_id,))
+        row = cur.fetchone()
+        today = date.today()
+        if not row:
+            cur.execute("INSERT INTO streaks(user_id,days,last_active) VALUES(%s,%s,%s)", (user_id, 1, today))
+        else:
+            last = row["last_active"]
+            days = int(row["days"] or 0)
+            if last is None or last < today:
+                # if we missed a day, reset to 1 else +1
+                if last and (today - last) > timedelta(days=1):
+                    days = 1
+                else:
+                    days = max(1, days + 1)
+                cur.execute("UPDATE streaks SET days=%s,last_active=%s WHERE user_id=%s", (days, today, user_id))
+
+# -- leaderboard helpders ---
+
+def leaderboard_for_class(class_id: int, limit: int = 10):
+    """
+    Returns: [{'user_id': int, 'name': str, 'xp': int, 'level': int}, ...]
+    Sorted by XP (desc) for students in a specific class.
+    """
+    with cursor() as cur:
+        cur.execute("""
+            SELECT 
+              u.user_id,
+              u.name,
+              COALESCE(x.total_xp, 0) AS xp
+            FROM class_students cs
+            JOIN users u ON u.user_id = cs.student_id
+            LEFT JOIN (
+              SELECT user_id, SUM(delta) AS total_xp
+              FROM xp_log
+              GROUP BY user_id
+            ) x ON x.user_id = u.user_id
+            WHERE cs.class_id = %s
+            ORDER BY COALESCE(x.total_xp, 0) DESC, u.name
+            LIMIT %s
+        """, (class_id, limit))
+        rows = cur.fetchall() or []
+    # attach levels using  curve
+    for r in rows:
+        r["level"] = level_from_xp(r.get("xp", 0))
+    return rows
+
+
+def leaderboard_global(limit: int = 10):
+    """
+    Returns: [{'user_id': int, 'name': str, 'xp': int, 'level': int}, ...]
+    Top students across the whole app by XP.
+    """
+    with cursor() as cur:
+        cur.execute("""
+            SELECT 
+              u.user_id,
+              u.name,
+              COALESCE(x.total_xp, 0) AS xp
+            FROM users u
+            LEFT JOIN (
+              SELECT user_id, SUM(delta) AS total_xp
+              FROM xp_log
+              GROUP BY user_id
+            ) x ON x.user_id = u.user_id
+            WHERE u.role_slug = 'student'
+            ORDER BY COALESCE(x.total_xp, 0) DESC, u.name
+            LIMIT %s
+        """, (limit,))
+        rows = cur.fetchall() or []
+    for r in rows:
+        r["level"] = level_from_xp(r.get("xp", 0))
+    return rows
+
+
+
+
+# --- Game logging helpers ---
+def record_money_match_play(user_id:int, *, target:int, total:int, elapsed_ms:int, matched:bool, gained_xp:int):
+    with cursor() as cur:
+        cur.execute("""
+            INSERT INTO game_sessions(user_id,game_slug,target,total,elapsed_ms,matched,gained_xp,ended_at)
+            VALUES(%s,'money_match',%s,%s,%s,%s,%s,NOW())
+        """, (user_id, target, total, elapsed_ms, 1 if matched else 0, gained_xp))
+        cur.execute("""
+            INSERT INTO money_match_history(user_id,target,total,elapsed_ms,gained_xp,matched)
+            VALUES(%s,%s,%s,%s,%s,%s)
+        """, (user_id, target, total, elapsed_ms, gained_xp, 1 if matched else 0))
+        cur.execute("""
+            INSERT INTO money_match_stats(user_id,total_xp,matches,best_time_ms,best_target)
+            VALUES(%s,%s,%s,%s,%s)
+            ON DUPLICATE KEY UPDATE
+              total_xp = total_xp + VALUES(total_xp),
+              matches  = matches  + VALUES(matches),
+              best_time_ms = LEAST(COALESCE(best_time_ms, VALUES(best_time_ms)), VALUES(best_time_ms)),
+              best_target  = COALESCE(best_target, VALUES(best_target))
+        """, (user_id, gained_xp, 1 if matched else 0, elapsed_ms if matched else None, target if matched else None))
+
+    _bump_game_stats(user_id, "money_match", gained_xp=gained_xp, matched=1 if matched else 0)
+    add_xp(user_id, gained_xp, "game", {"game":"money_match","target":target,"total":total,"elapsed_ms":elapsed_ms,"matched":matched})
+
+def record_budget_builder_save(user_id:int, *, weekly_allowance:int, allocations:list[dict]):
+    total_allocated = sum(int(x.get("amount",0)) for x in allocations)
+    remaining = int(weekly_allowance) - total_allocated
+    gained_xp = 150 if remaining == 0 else 100 if remaining > 0 else 50
+    with cursor() as cur:
+        cur.execute("""
+            INSERT INTO game_sessions(user_id,game_slug,gained_xp,ended_at)
+            VALUES(%s,'budget_builder',%s,NOW())
+        """, (user_id, gained_xp))
+        cur.execute("""
+            INSERT INTO budget_builder_history(user_id,weekly_allowance,allocations,total_allocated,remaining,gained_xp)
+            VALUES(%s,%s,%s,%s,%s,%s)
+        """, (user_id, weekly_allowance, json.dumps(allocations), total_allocated, remaining, gained_xp))
+        cur.execute("""
+            INSERT INTO budget_builder_stats(user_id,total_xp,plays,best_balance)
+            VALUES(%s,%s,1,%s)
+            ON DUPLICATE KEY UPDATE
+              total_xp = total_xp + VALUES(total_xp),
+              plays    = plays + 1,
+              best_balance = GREATEST(COALESCE(best_balance, 0), VALUES(best_balance))
+        """, (user_id, gained_xp, remaining))
+
+    _bump_game_stats(user_id, "budget_builder", gained_xp=gained_xp, matched=1)
+    add_xp(user_id, gained_xp, "game", {"game":"budget_builder","remaining":remaining})
+
+def record_debt_dilemma_round(
+    user_id:int, *,
+    level:int, round_no:int,
+    wallet:int, health:int, happiness:int, credit_score:int,
+    event_json:dict, outcome:str, gained_xp:int
+):
+    with cursor() as cur:
+        cur.execute("""
+            INSERT INTO game_sessions(user_id,game_slug,gained_xp,ended_at)
+            VALUES(%s,'debt_dilemma',%s,NOW())
+        """, (user_id, gained_xp))
+        cur.execute("""
+            INSERT INTO debt_dilemma_history(user_id,level,round_no,wallet,health,happiness,credit_score,event_json,outcome,gained_xp)
+            VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
+        """, (user_id, level, round_no, wallet, health, happiness, credit_score, json.dumps(event_json or {}), outcome, gained_xp))
+        cur.execute("""
+            INSERT INTO debt_dilemma_stats(user_id,total_xp,plays,highest_level,last_outcome)
+            VALUES(%s,%s,1,%s,%s)
+            ON DUPLICATE KEY UPDATE
+              total_xp = total_xp + VALUES(total_xp),
+              plays    = plays + 1,
+              highest_level = GREATEST(COALESCE(highest_level,0), VALUES(highest_level)),
+              last_outcome  = VALUES(last_outcome)
+        """, (user_id, gained_xp, level, outcome))
+
+    # Treat a completed month/level as a "match"
+    _bump_game_stats(user_id, "debt_dilemma", gained_xp=gained_xp, matched=1, level_inc=level)
+    add_xp(user_id, gained_xp, "game", {
+        "game":"debt_dilemma","level":level,"round":round_no,"outcome":outcome
+    })
+
+
+def record_profit_puzzle_result(
+    user_id:int, *,
+    scenario_id:str,
+    title:str,
+    units:int, price:int, cost:int,
+    user_answer:float, actual_profit:float,
+    is_correct:bool, gained_xp:int
+):
+    with cursor() as cur:
+        # generic session row for cross-game views
+        cur.execute("""
+            INSERT INTO game_sessions(user_id,game_slug,gained_xp,ended_at)
+            VALUES(%s,'profit_puzzle',%s,NOW())
+        """, (user_id, int(gained_xp)))
+
+        # detailed history
+        cur.execute("""
+            INSERT INTO profit_puzzle_history
+              (user_id,scenario_id,title,units,price,cost,user_answer,actual_profit,is_correct,gained_xp)
+            VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
+        """, (user_id, scenario_id, title, int(units), int(price), int(cost),
+              float(user_answer), float(actual_profit), 1 if is_correct else 0, int(gained_xp)))
+
+        # per-game stats
+        cur.execute("""
+            INSERT INTO profit_puzzle_stats(user_id,total_xp,plays,correct,last_score)
+            VALUES(%s,%s,1,%s,%s)
+            ON DUPLICATE KEY UPDATE
+              total_xp   = total_xp + VALUES(total_xp),
+              plays      = plays + 1,
+              correct    = correct + VALUES(correct),
+              last_score = VALUES(last_score),
+              last_played = CURRENT_TIMESTAMP
+        """, (user_id, int(gained_xp), 1 if is_correct else 0, int(gained_xp)))
+
+        # game_stats rollup like  other games
+        cur.execute("""
+            INSERT INTO game_stats(user_id,game_slug,total_xp,matches,level)
+            VALUES(%s,'profit_puzzle',%s,%s,1)
+            ON DUPLICATE KEY UPDATE
+              total_xp = total_xp + VALUES(total_xp),
+              matches  = matches + VALUES(matches)
+        """, (user_id, int(gained_xp), 1 if is_correct else 0))
+
+    # global XP and streak
+    add_xp(user_id, int(gained_xp), "game",
+           {"game":"profit_puzzle","scenario":scenario_id,"correct":bool(is_correct)})
+
+    # --- Profit Puzzle logging ---
+def record_profit_puzzle_progress(user_id:int, *, scenario_title:str, correct:bool, gained_xp:int):
+    """
+    Log a Profit Puzzle step and bump XP.
+    - Writes to generic game_sessions and game_stats
+    - Writes to xp_log via add_xp
+    """
+    with cursor() as cur:
+        # session line item
+        cur.execute("""
+            INSERT INTO game_sessions(user_id, game_slug, gained_xp, ended_at)
+            VALUES(%s, 'profit_puzzle', %s, NOW())
+        """, (user_id, int(gained_xp)))
+
+        # aggregate by game
+        cur.execute("""
+            INSERT INTO game_stats(user_id, game_slug, total_xp, matches, level)
+            VALUES(%s, 'profit_puzzle', %s, %s, 1)
+            ON DUPLICATE KEY UPDATE
+              total_xp = total_xp + VALUES(total_xp),
+              matches  = matches + VALUES(matches)
+        """, (user_id, int(gained_xp), 1 if correct else 0))
+
+    add_xp(
+        user_id,
+        int(gained_xp),
+        "game",
+        {"game": "profit_puzzle", "scenario": scenario_title, "correct": bool(correct)}
+    )

utils/quizdata.py

@@ -0,0 +1,260 @@
+quizzes_data = {
+    1: {
+        "title": "Module 1: Budgeting Basics",
+        "description": "Learn the fundamentals of budgeting and money management",
+        "level": "Beginner",
+        "duration": "15 min",
+        "questions": [
+            {
+                "question": "Which of these is considered a 'need' rather than a 'want'?",
+                "options": ["Latest smartphone", "Designer clothes", "Basic shelter and housing", "Streaming subscriptions"],
+                "answer": "Basic shelter and housing",
+                "explanation": "Shelter is essential for survival, while others are lifestyle wants."
+            },
+            {
+                "question": "What is the 50/30/20 budgeting rule?",
+                "options": [
+                    "50% needs, 30% wants, 20% savings",
+                    "30% needs, 50% wants, 20% savings",
+                    "20% needs, 50% savings, 30% wants",
+                    "40% needs, 40% wants, 20% savings"
+                ],
+                "answer": "50% needs, 30% wants, 20% savings",
+                "explanation": "This rule allocates income to essentials, lifestyle, and savings/debt repayment."
+            },
+            {
+                "question": "What should you do first when creating a budget?",
+                "options": [
+                    "Track your income and expenses for a month",
+                    "Get a loan",
+                    "Buy less food",
+                    "Invest in stocks"
+                ],
+                "answer": "Track your income and expenses for a month",
+                "explanation": "Tracking helps you understand spending patterns before planning a budget."
+            },
+            {
+                "question": "How often should you review and update your budget?",
+                "options": ["Every week", "Monthly", "Yearly", "Never"],
+                "answer": "Monthly",
+                "explanation": "Budgets should be reviewed monthly to reflect financial changes."
+            },
+            {
+                "question": "What percentage of income should ideally go to housing costs?",
+                "options": ["10% or less", "30% or less", "50% or less", "70% or less"],
+                "answer": "30% or less",
+                "explanation": "Experts recommend keeping housing costs at 30% or less of gross income."
+            },
+        ]
+    },
+    2: {
+        "title": "Module 2: Saving & Emergency Funds",
+        "description": "Master the art of saving and building financial security",
+        "level": "Beginner",
+        "duration": "12 min",
+        "questions": [
+            {
+                "question": "What is the primary purpose of an emergency fund?",
+                "options": [
+                    "To buy luxury items",
+                    "To cover unexpected expenses",
+                    "To invest in the stock market",
+                    "To pay monthly bills"
+                ],
+                "answer": "To cover unexpected expenses",
+                "explanation": "An emergency fund provides financial security during unplanned situations."
+            },
+            {
+                "question": "How much should you ideally save in an emergency fund?",
+                "options": [
+                    "1 month of expenses",
+                    "3–6 months of expenses",
+                    "12 months of expenses",
+                    "No fixed amount"
+                ],
+                "answer": "3–6 months of expenses",
+                "explanation": "Experts recommend saving enough to cover 3–6 months of living expenses."
+            },
+            {
+                "question": "Where should you keep your emergency fund?",
+                "options": [
+                    "In a checking or savings account",
+                    "In risky stocks",
+                    "In real estate",
+                    "Locked in a retirement account"
+                ],
+                "answer": "In a checking or savings account",
+                "explanation": "Emergency funds should be liquid and easily accessible."
+            },
+            {
+                "question": "What is the difference between saving and investing?",
+                "options": [
+                    "Saving is riskier than investing",
+                    "Investing is short-term, saving is long-term",
+                    "Saving is for safety, investing is for growth",
+                    "They are the same thing"
+                ],
+                "answer": "Saving is for safety, investing is for growth",
+                "explanation": "Savings are secure, while investments aim for higher returns with more risk."
+            },
+        ]
+    },
+    3: {
+        "title": "Module 3: Investment Fundamentals",
+        "description": "Understanding the basics of investing and growing wealth",
+        "level": "Intermediate",
+        "duration": "20 min",
+        "questions": [
+            {
+                "question": "Which of these is considered a low-risk investment?",
+                "options": ["Stocks", "Bonds", "Cryptocurrency", "Options trading"],
+                "answer": "Bonds",
+                "explanation": "Bonds are generally safer than stocks and other volatile investments."
+            },
+            {
+                "question": "What is diversification in investing?",
+                "options": [
+                    "Putting all money into one stock",
+                    "Spreading investments across different assets",
+                    "Investing only in foreign companies",
+                    "Investing only in real estate"
+                ],
+                "answer": "Spreading investments across different assets",
+                "explanation": "Diversification reduces risk by not relying on a single asset."
+            },
+            {
+                "question": "Which investment typically has the highest risk?",
+                "options": ["Savings account", "Treasury bonds", "Stocks", "Cryptocurrency"],
+                "answer": "Cryptocurrency",
+                "explanation": "Cryptocurrencies are highly volatile compared to traditional investments."
+            },
+            {
+                "question": "What does 'compound interest' mean?",
+                "options": [
+                    "Interest earned only on the original deposit",
+                    "Interest earned on both the deposit and accumulated interest",
+                    "A type of tax on investments",
+                    "A penalty for late payments"
+                ],
+                "answer": "Interest earned on both the deposit and accumulated interest",
+                "explanation": "Compound interest accelerates growth by earning interest on interest."
+            },
+            {
+                "question": "Which of these is considered a retirement investment account?",
+                "options": ["401(k)", "Credit card", "Checking account", "Car loan"],
+                "answer": "401(k)",
+                "explanation": "A 401(k) is a retirement savings account that offers tax advantages."
+            },
+        ]
+    },
+    4: {
+        "title": "Module 4: Credit & Debt Management",
+        "description": "Learn how to manage credit and debt responsibly",
+        "level": "Intermediate",
+        "duration": "18 min",
+        "questions": [
+            {
+                "question": "Which of these improves your credit score?",
+                "options": [
+                    "Paying bills on time",
+                    "Maxing out your credit cards",
+                    "Closing old credit accounts",
+                    "Missing payments occasionally"
+                ],
+                "answer": "Paying bills on time",
+                "explanation": "On-time payments are the biggest factor in a good credit score."
+            },
+            {
+                "question": "What is a common consequence of only making minimum credit card payments?",
+                "options": [
+                    "You avoid all interest charges",
+                    "It takes longer to pay off debt with more interest",
+                    "Your credit score immediately improves",
+                    "You save money in the long run"
+                ],
+                "answer": "It takes longer to pay off debt with more interest",
+                "explanation": "Minimum payments extend repayment time and increase total interest costs."
+            },
+            {
+                "question": "What is a 'debt-to-income ratio'?",
+                "options": [
+                    "Your income compared to your expenses",
+                    "Your monthly debt compared to your monthly income",
+                    "Your total debt compared to your savings",
+                    "Your credit score number"
+                ],
+                "answer": "Your monthly debt compared to your monthly income",
+                "explanation": "Lenders use this ratio to assess your ability to manage debt."
+            },
+            {
+                "question": "Which strategy is best for paying off multiple debts quickly?",
+                "options": [
+                    "Debt snowball (pay smallest debts first)",
+                    "Debt avalanche (pay highest interest debts first)",
+                    "Pay all debts equally",
+                    "Ignore debts until they go away"
+                ],
+                "answer": "Debt avalanche (pay highest interest debts first)",
+                "explanation": "Debt avalanche minimizes interest payments by targeting high-interest debt first."
+            },
+        ]
+    },
+    5: {
+        "title": "General Financial Knowledge",
+        "description": "Test your overall financial literacy across all topics",
+        "level": "Intermediate",
+        "duration": "25 min",
+        "questions": [
+            {
+                "question": "What does 'inflation' mean?",
+                "options": [
+                    "Decrease in overall price levels",
+                    "Increase in overall price levels",
+                    "A government tax increase",
+                    "Stock market growth"
+                ],
+                "answer": "Increase in overall price levels",
+                "explanation": "Inflation is the general rise in prices over time."
+            },
+            {
+                "question": "What is the main purpose of insurance?",
+                "options": [
+                    "To generate investment returns",
+                    "To protect against financial loss",
+                    "To avoid paying taxes",
+                    "To increase monthly expenses"
+                ],
+                "answer": "To protect against financial loss",
+                "explanation": "Insurance transfers financial risk from you to the insurer."
+            },
+            {
+                "question": "What is net income?",
+                "options": [
+                    "Total income before taxes",
+                    "Income after taxes and deductions",
+                    "The same as gross income",
+                    "Investment profits only"
+                ],
+                "answer": "Income after taxes and deductions",
+                "explanation": "Net income is the money you take home after deductions."
+            },
+            {
+                "question": "Which financial product typically has the highest interest rate?",
+                "options": ["Mortgage loan", "Credit card", "Student loan", "Car loan"],
+                "answer": "Credit card",
+                "explanation": "Credit cards usually have higher interest rates than other types of loans."
+            },
+            {
+                "question": "What is diversification in finance?",
+                "options": [
+                    "Spreading money across different assets to reduce risk",
+                    "Putting all money into one high-performing stock",
+                    "Avoiding investments completely",
+                    "Buying only government bonds"
+                ],
+                "answer": "Spreading money across different assets to reduce risk",
+                "explanation": "Diversification reduces exposure to risk by investing in various asset classes."
+            },
+        ]
+    },
+}