feat: import backend code (clean history)

app.py

@@ -0,0 +1,308 @@
+
+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
+import os
+from dotenv import load_dotenv
+
+
+load_dotenv()
+
+
+# --- 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()
+
+                    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()
+
+                    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:
+                    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,175 @@
+import os
+import streamlit as st
+from phase.Student_view import chatbot, lesson, quiz
+from utils import db as dbapi
+
+# --- 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
+    stats = dbapi.user_xp_and_level(student_id) if hasattr(dbapi, "user_xp_and_level") else {"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”
+    rows = dbapi.list_assignments_for_student(student_id) if hasattr(dbapi, "list_assignments_for_student") else []
+
+    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
+
+    quiz_score = dbapi.student_quiz_average(student_id) if hasattr(dbapi, "student_quiz_average") else 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
+    recent_lessons = dbapi.recent_lessons_for_student(student_id, limit=5) if hasattr(dbapi, "recent_lessons_for_student") else []
+
+    # 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("")
+
+    # --- 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("---")
+
+    # --- XP Bar ---
+    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("")
+
+
+    # --- 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,204 @@
+# dashboards/teacher_db.py
+import streamlit as st
+import os
+import plotly.express as px
+import plotly.graph_objects as go
+import csv
+import io
+import datetime
+from utils import db as dbapi
+
+def load_css(file_name):
+    try:
+        with open(file_name, 'r') 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 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():
+                    out = dbapi.create_class(teacher_id, new_class_name.strip())
+                    st.success(f"Classroom created. Code: **{out['code']}**")
+
+    # ========== TILES ==========
+    tiles = dbapi.teacher_tiles(teacher_id)
+    c1,c2,c3,c4 = st.columns(4)
+    c1.markdown(tile("👥","Total Students", tiles["total_students"]), unsafe_allow_html=True)
+    c2.markdown(tile("📊","Class Average", f"{int(tiles['class_avg']*100)}%"), unsafe_allow_html=True)
+    c3.markdown(tile("📚","Lessons Created", tiles["lessons_created"]), unsafe_allow_html=True)
+    c4.markdown(tile("📈","Active Students", tiles["active_students"]), unsafe_allow_html=True)
+
+    # ========== CLASS PICKER ==========
+    classes = dbapi.list_classes_by_teacher(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]['name']} (Code: {classes[i].get('code','')})"
+    )
+    selected = classes[idx]
+    class_id = selected["class_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 = dbapi.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 = dbapi.class_weekly_activity(class_id)
+        if activity:
+            days = []
+            lessons, quizzes, games = [], [], []
+            for row in activity:
+                date_str = row.get("date")
+                try:
+                    day = datetime.datetime.fromisoformat(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 = dbapi.class_progress_overview(class_id)
+        overall_pct = int(round((prog["overall_progress"] or 0) * 100))
+        quiz_pct    = int(round((prog["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["lessons_completed"])
+        k2.metric("🪙 Total Class XP", prog["class_xp"])
+
+    # ========== 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 = dbapi.class_recent_activity(class_id, limit=6, days=30)
+        if not feed:
+            st.caption("Nothing yet. Assign something, chief.")
+        else:
+            for r in feed:
+                icon = "📘" if r["kind"] == "lesson" else "🏆" if r["kind"] == "quiz" else "🎮"
+                lvl = dbapi.level_from_xp(r.get("total_xp", 0))
+                tail = f" · {r['extra']}" if r.get("extra") else ""
+                st.write(f"{icon} **{r['student_name']}** — {r['item_title']}{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['name']}  · Code **{c.get('code','')}**"):
+            st.write(f"Students: {c['total_students']}")
+            st.write(f"Average score: {round(c['class_avg']*100)}%")
+            roster = dbapi.list_students_in_class(c["class_id"])
+            if roster:
+                for s in roster:
+                    st.write(f"- {s['name']} · {s['email']} · Level {s['level_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-----

utils/db.py

@@ -0,0 +1,1266 @@
+# utils/db.py (top of file)
+import os
+import json
+import certifi
+import mysql.connector
+from mysql.connector import Error
+from contextlib import contextmanager
+from datetime import date, timedelta    
+
+# 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 list_classes_by_teacher(teacher_id:int):
+    with cursor() as cur:
+        cur.execute("SELECT * FROM v_class_stats WHERE teacher_id=%s", (teacher_id,))
+        return cur.fetchall()
+
+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):
+    with cursor() as cur:
+        cur.execute("SELECT COALESCE(SUM(delta),0) AS xp FROM xp_log WHERE user_id=%s", (user_id,))
+        xp = (cur.fetchone() or {"xp": 0})["xp"]
+        # simple leveling curve: every 500 XP is a level
+        level = max(1, (xp // 500) + 1)
+        # streak
+        cur.execute("SELECT days FROM streaks WHERE user_id=%s", (user_id,))
+        row = cur.fetchone()
+        streak = int(row["days"]) if row and row.get("days") is not None else 0
+    return dict(xp=int(xp), level=int(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."
+            },
+        ]
+    },
+}