feat: import backend code (clean history)

phase/Student_view/chatbot.py

@@ -0,0 +1,107 @@
+import streamlit as st
+import datetime
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+
+# Load environment variables from .env file if present
+load_dotenv()
+
+# Ensure OPENAI_API_KEY is set
+api_key = os.getenv("OPENAI_API_KEY")
+if not api_key:
+    st.error("⚠️ Please set the OPENAI_API_KEY environment variable or .env file before running the app.")
+
+client = OpenAI(api_key=api_key)
+
+# --- Helper to add message ---
+def add_message(text: str, sender: str):
+    st.session_state.messages.append(
+        {
+            "id": str(datetime.datetime.now().timestamp()),
+            "text": text,
+            "sender": sender,
+            "timestamp": datetime.datetime.now()
+        }
+    )
+
+def show_page():
+    st.title("🤖 AI Financial Tutor")
+    st.caption("Get personalized help with your financial questions")
+
+    # --- Initialize state ---
+    if "messages" not in st.session_state:
+        st.session_state.messages = [
+            {
+                "id": "1",
+                "text": "Hi! I'm your AI Financial Tutor. I'm here to help you learn about personal finance, investing, budgeting, and more. What would you like to know?",
+                "sender": "assistant",
+                "timestamp": datetime.datetime.now()
+            }
+        ]
+    if "is_typing" not in st.session_state:
+        st.session_state.is_typing = False
+
+    # --- Chat Container ---
+    chat_container = st.container()
+    with chat_container:
+        for msg in st.session_state.messages:
+            if msg["sender"] == "assistant":
+                st.markdown(f"<div style='background-color:#e0e0e0; color:black; padding:10px; border-radius:12px; max-width:70%; margin-bottom:5px;'>{msg['text']}<br><sub>{msg['timestamp'].strftime('%H:%M')}</sub></div>", unsafe_allow_html=True)
+            else:
+                st.markdown(f"<div style='background-color:#4CAF50; color:white; padding:10px; border-radius:12px; max-width:70%; margin-left:auto; margin-bottom:5px;'>{msg['text']}<br><sub>{msg['timestamp'].strftime('%H:%M')}</sub></div>", unsafe_allow_html=True)
+
+        if st.session_state.is_typing:
+            st.markdown("🤖 _FinanceBot is typing..._")
+
+    # --- Quick Questions ---
+    if len(st.session_state.messages) == 1:
+        st.markdown("Try asking about:")
+        cols = st.columns(2)
+        quick_questions = [
+            "How does compound interest work?",
+            "How much should I save for emergencies?",
+            "What's a good budgeting strategy?",
+            "How do I start investing?"
+        ]
+        for i, q in enumerate(quick_questions):
+            if cols[i % 2].button(q):
+                add_message(q, "user")
+                st.session_state.is_typing = True
+                st.rerun()
+
+    # --- Input Box ---
+    user_input = st.chat_input("Ask me anything about personal finance...")
+    if user_input:
+        add_message(user_input, "user")
+        st.session_state.is_typing = True
+        st.rerun()
+
+    # --- Call OpenAI API directly ---
+    if st.session_state.is_typing:
+        try:
+            with st.spinner("FinanceBot is thinking..."):
+                messages_payload = [
+                    {"role": m['sender'], "content": m['text']} for m in st.session_state.messages
+                ]
+                # Ensure role is either 'user' or 'assistant'
+                for m in messages_payload:
+                    if m['role'] not in ['user', 'assistant']:
+                        m['role'] = 'user'
+
+                response = client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=messages_payload
+                )
+                bot_reply = response.choices[0].message.content
+                add_message(bot_reply, "assistant")
+        except Exception as e:
+            add_message(f"⚠️ Error: {e}", "assistant")
+        finally:
+            st.session_state.is_typing = False
+            st.rerun()
+
+    # --- Navigation Button ---
+    if st.button("Back to Dashboard", key="ai_tutor_back_btn"):
+        st.session_state.current_page = "Student Dashboard"
+        st.rerun()

phase/Student_view/game.py

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

phase/Student_view/games/MoneyMatch.py

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

phase/Student_view/games/budgetbuilder.py

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

phase/Student_view/games/debtdilemma.py

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

phase/Student_view/games/profitpuzzle.py

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

phase/Student_view/lesson.py

@@ -0,0 +1,717 @@
+import streamlit as st
+from utils import db as dbapi
+import os
+
+
+# --- Load external CSS ---
+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.")
+
+
+# --- Data structure for lessons ---
+lessons_by_level = {
+    "beginner": [
+        {
+            "id": 1,
+            "title": "Introduction to Money",
+            "description": "Learn the basics of what money is, its history and how it works",
+            "duration": "20 min",
+            "completed": False,
+            "locked": False,
+            "difficulty": "Easy",
+            "content": "",
+            "topics": ["What is money? (coins, notes, digital money)",
+                       "History of money in Jamaica (Jamaican coins, notes, and famous historical figures)",
+                       "How money is used in daily life",
+                       "Different types of currencies",
+                       "Recognizing and counting Jamaican coins and notes",
+                       "Play: Money Match","Quiz", "Summary"]
+        },
+        {
+            "id": 2,
+            "title": "Earning and Spending",
+            "description": "Start building the habit of saving money",
+            "duration": "8 min",
+            "completed": False,
+            "locked": False,
+            "difficulty": "Easy",
+             "topics": ["Jobs people do to earn money",
+                       "Allowances and pocket money",
+                       "Basic needs vs wants",
+                       "Making choices when spending",
+                       "Simple budget for small items",
+                       "Play: Budget Builder","Quiz", "Summary"]
+        },
+        {
+            "id": 3,
+            "title": "Saving Money",
+            "description": "Learn to distinguish between essential and optional purchases",
+            "duration": "12 min",
+            "completed": False,
+            "locked": False,
+            "difficulty": "Easy",
+             "topics": ["Why saving is important",
+                       "Where to save (piggy banks, banks)",
+                       "Basic needs vs wants",
+                       "Setting small savings goals",
+                       "Reward of saving (buying a toy, snack, or school supplies)",
+                       "Play Piggy Bank challenge","Quiz", "Summary"]
+        },
+         {
+            "id": 4,
+            "title": "Simple Financial Responsibility",
+            "description": "Learn to distinguish between essential and optional purchases",
+            "duration": "12 min",
+            "completed": False,
+            "locked": False,
+            "difficulty": "Easy",
+             "topics": ["Making smart choices with money",
+                       "Giving and sharing (donations, helping family/friends)",
+                       "Recognizing scams or unsafe spending",
+                       "Introduction to keeping a simple money diary",
+                       "Play Smart Shopper","Quiz", "Summary"]
+        }
+    ],
+    "intermediate": [
+        {
+            "id": 5,
+            "title": "Understanding Compound Interest",
+            "description": "Learn how your money can grow exponentially over time",
+            "duration": "15 min",
+            "completed": True,
+            "locked": False,
+            "difficulty": "Medium",
+            "content": "Compound interest is the eighth wonder of the world..."
+        },
+        {
+            "id": 6,
+            "title": "Building an Emergency Fund",
+            "description": "Create a financial safety net for unexpected expenses",
+            "duration": "12 min",
+            "completed": False,
+            "locked": False,
+            "difficulty": "Medium",
+            "content": "An emergency fund is your financial security blanket..."
+        },
+        {
+            "id": 7,
+            "title": "Introduction to Investing",
+            "description": "Basic concepts of making your money work for you",
+            "duration": "18 min",
+            "completed": False,
+            "locked": False,
+            "difficulty": "Medium",
+            "content": "Investing is putting your money to work..."
+        }
+    ],
+    "advanced": [
+        {
+            "id": 8,
+            "title": "Stock Market Mastery",
+            "description": "Advanced strategies for stock market investing",
+            "duration": "25 min",
+            "completed": False,
+            "locked": True,
+            "difficulty": "Hard",
+            "content": "Deep dive into stock analysis, market trends..."
+        },
+        {
+            "id": 9,
+            "title": "Retirement Planning Strategies",
+            "description": "Advanced retirement and tax-advantaged planning",
+            "duration": "30 min",
+            "completed": False,
+            "locked": True,
+            "difficulty": "Hard",
+            "content": "Advanced retirement planning strategies including 401(k)..."
+        },
+        {
+            "id": 10,
+            "title": "Real Estate Investment",
+            "description": "Building wealth through property investment",
+            "duration": "22 min",
+            "completed": False,
+            "locked": True,
+            "difficulty": "Hard",
+            "content": "Learn about real estate as an investment vehicle..."
+        }
+    ]
+}
+
+# --- Utility functions ---
+
+def _db_to_general_lesson_shape(L: dict, sections: list) -> dict:
+    """Convert a DB lesson+sections into the same dict shape used by general lessons."""
+    level = (L.get("level") or "beginner").lower()
+    difficulty = {"beginner": "Easy", "intermediate": "Medium", "advanced": "Hard"}.get(level, "Easy")
+    topics = [ (s.get("title") or f"Topic {i+1}") for i, s in enumerate(sections) ]
+
+    # pick a duration heuristic if you don’t store it
+    duration = L.get("duration") or f"{max(6, len(topics)*6)} min"
+
+    return {
+        "id": int(L["lesson_id"]),
+        "title": L.get("title") or "Untitled",
+        "description": L.get("description") or "",
+        "duration": duration,
+        "completed": False,
+        "locked": False,
+        "difficulty": difficulty,
+        "topics": topics,
+        # keep optional extra fields if you like:
+        "_db_sections": sections,     # stash raw sections so our DB renderer can use them
+        "_db_level": level,
+    }
+
+
+def get_difficulty_color(difficulty):
+    """Return color based on difficulty level"""
+    colors = {
+        "Easy": "#28a745",      # Green
+        "Medium": "#ffc107",    # Yellow
+        "Hard": "#dc3545"       # Red
+    }
+    return colors.get(difficulty, "#6c757d")
+
+def get_level_info(level):
+
+    level_info = {
+        "beginner": {
+            "display": "🌱 Beginner",
+            "color": "#28a745",
+            "description": "Build your financial foundation"
+        },
+        "intermediate": {
+            "display": "🚀 Intermediate", 
+            "color": "#007bff",
+            "description": "Grow your financial knowledge"
+        },
+        "advanced": {
+            "display": "🎓 Advanced",
+            "color": "#6f42c1",
+            "description": "Master advanced strategies"
+        }
+    }
+    return level_info.get(level, level_info["beginner"])
+
+# --- Per-user lesson progress (in memory via session_state) ---
+def _ensure_progress_state():
+    if "topic_progress" not in st.session_state:
+        st.session_state.topic_progress = {}  # {lesson_id: max_topic_index_seen}
+    if "lesson_completed" not in st.session_state:
+        st.session_state.lesson_completed = {}  # {lesson_id: True/False}
+
+def _mark_topic_seen(lesson_id: int, topic_index: int):
+    _ensure_progress_state()
+    current = st.session_state.topic_progress.get(lesson_id, 0)
+    st.session_state.topic_progress[lesson_id] = max(current, topic_index)
+
+def _is_lesson_completed(lesson_id: int) -> bool:
+    _ensure_progress_state()
+    return st.session_state.lesson_completed.get(lesson_id, False)
+
+def _complete_lesson(lesson):
+    _ensure_progress_state()
+    st.session_state.lesson_completed[lesson["id"]] = True
+    # reflect in the in-memory lessons list too (so the cards show ✓)
+    lesson["completed"] = True
+
+
+#-----
+
+def show_lesson_cards(lessons, user_level):
+
+    level_info = get_level_info(user_level)
+    
+    # Level header
+    st.markdown(f"""
+    <div style="background-color: {level_info['color']}; color: white; padding: 1.5rem; border-radius: 12px; margin-bottom: 2rem;">
+        <h2 style="margin: 0; font-size: 2rem;">{level_info['display']}</h2>
+        <p style="margin: 0.5rem 0 0 0; font-size: 1.1rem; opacity: 0.9;">{level_info['description']}</p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Stats
+    total_lessons = len(lessons)
+    completed_lessons = sum(1 for lesson in lessons if lesson["completed"])
+    
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.metric("📚 Total Lessons", total_lessons)
+    with col2:
+        st.metric("✅ Completed", completed_lessons)
+    with col3:
+        st.metric("📈 Progress", f"{int((completed_lessons/total_lessons)*100)}%")
+    with col4:
+        available_lessons = sum(1 for lesson in lessons if not lesson["locked"])
+        st.metric("🔓 Available", available_lessons)
+    
+    st.markdown("---")
+    
+    # Display lessons in a 3-column grid like Microsoft Learn
+    cols = st.columns(3)
+    
+    for i, lesson in enumerate(lessons):
+        lesson["completed"] = lesson.get("completed") or _is_lesson_completed(lesson["id"])
+
+        with cols[i % 3]:
+            # Determine card status and styling
+            if lesson["locked"]:
+                icon_html = '🔒'
+                card_opacity = "0.6"
+            elif lesson["completed"]:
+                icon_html = '✓'
+                card_opacity = "1"
+            else:
+                icon_html = '📖'
+                card_opacity = "1"
+            
+            card_html = f"""
+            <div class="lesson-card" style="
+                background: white; 
+                border: 1px solid #e1e5e9; 
+                border-radius: 8px; 
+                padding: 24px; 
+                margin-bottom: 15px; 
+                opacity: {card_opacity}; 
+                box-shadow: 0 2px 4px rgba(0,0,0,0.1); 
+                height: 250px;
+                transition: all 0.3s ease;
+                cursor: pointer;
+            ">
+                <div style="display: flex; justify-content: space-between; align-items: flex-start;">
+                    <h3 style="margin: 0; font-size: 18px; font-weight: 600; color: #323130; line-height: 1.3;">{lesson['title']}</h3>
+                    <div style="color: #28a745; font-size: 24px;">{icon_html}</div>
+                </div>
+                <p style="margin: 0 0 16px 0; color: #605e5c; font-size: 14px; line-height: 1.4;">{lesson['description']}</p>
+                <div style="margin-bottom: 16px;">
+                    <span style="background-color: #f3f2f1; color: #323130; padding: 4px 8px; border-radius: 4px; font-size: 12px; font-weight: 500;">{lesson['difficulty']}</span>
+                </div>
+                <div style="color: #0078d4; font-size: 14px; font-weight: 500;">{lesson['duration']}</div>
+            </div>
+            """
+            
+            st.markdown(card_html, unsafe_allow_html=True)
+            
+            # Native Streamlit buttons that actually work
+            if lesson["locked"]:
+                st.button("🔒 Locked", key=f"lesson_locked_{lesson['id']}", disabled=True, use_container_width=True)
+            elif lesson["completed"]:
+                if st.button("✅ Review", key=f"lesson_review_{lesson['id']}", use_container_width=True, type="secondary"):
+                    st.session_state.selected_lesson = lesson["id"]
+                    st.rerun()
+            else:
+                if st.button("▶ Start Lesson", key=f"lesson_btn_{lesson['id']}", type="primary", use_container_width=True):
+                    st.session_state.selected_lesson = lesson["id"]
+                    st.rerun()
+
+
+
+def show_lesson_detail(lesson):
+    st.markdown(f"""
+        <h1 style="font-size:2.5rem; margin-bottom:0;">{lesson['title']}</h1>
+        <p style="color: #666; margin-top:0;">{lesson['duration']} &nbsp;•&nbsp; Module &nbsp;•&nbsp; {len(lesson.get("topics", []))} units</p>
+        <hr style="margin:1rem 0;"/>
+    """, unsafe_allow_html=True)
+
+    # Learning objectives section
+    st.subheader("Learning objectives")
+    st.markdown("""
+    <p style="color:#888; margin-bottom:0.5rem;">In this module, you'll</p>
+    """, unsafe_allow_html=True)
+    
+    st.markdown(
+        "- Focus on: Basic money concepts  \n"
+        "- Saving  \n"
+        "- Spending  \n"
+        "- Understanding simple financial transactions"
+    )
+
+    # Start button
+    if st.button("▶ Start", key=f"start_{lesson['id']}", type="primary"):
+        st.session_state.start_lesson = True
+        st.session_state.current_topic = 1
+        # reset progress for this lesson only if not previously completed
+        _ensure_progress_state()
+        if not _is_lesson_completed(lesson["id"]):
+            st.session_state.topic_progress[lesson["id"]] = 1
+        st.rerun()
+
+
+    st.markdown("---")
+
+    # Topics list (with clickable links)
+    st.subheader("Topics")
+    for i, t in enumerate(lesson.get("topics", []), start=1):
+        st.markdown(f"- [{t}](#topic-{i})")
+
+    st.markdown("---")
+
+    # Back button
+    if st.button("⬅ Back to Lessons", key=f"back_{lesson['id']}"):
+        st.session_state.selected_lesson = None
+        st.rerun()
+
+
+
+def load_topic_content(lesson_id, topic_index):
+    """Load topic content for a specific lesson and topic index"""
+    file_path = os.path.join("phase", "Student_view", "lessons", f"lesson_{lesson_id}", f"topic_{topic_index}.txt")
+    if os.path.exists(file_path):
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                return f.read()
+        except Exception as e:
+            return f"⚠️ Error loading topic content: {e}"
+    return "⚠️ Topic content not available."
+
+
+def show_lesson_page(lesson, lessons):
+    # Back link
+    if st.button("⬅ Back to Lessons", key=f"back_top_{lesson['id']}"):
+        st.session_state.selected_lesson = None
+        st.session_state.current_topic = 1
+        st.session_state.current_lesson = None
+        st.session_state.start_lesson = False
+        st.rerun()
+
+    # Header
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg,#20c997,#17a2b8); padding: 1.5rem; border-radius: 12px; color: white; margin-bottom: 2rem;">
+        <h2 style="margin:0;">{lesson['title']}</h2>
+        <p style="margin:0.3rem 0;">{lesson['description']}</p>
+        <div style="margin-top:0.5rem;">
+            <span style="background:#ffffff22; padding:6px 12px; border-radius:6px; margin-right:6px;">⏱ {lesson['duration']}</span>
+            <span style="background:#ffffff22; padding:6px 12px; border-radius:6px; margin-right:6px;">📘 Module {lesson['id']}</span>
+            <span style="background:#ffffff22; padding:6px 12px; border-radius:6px;">⭐ {lesson['difficulty']}</span>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Two-column layout
+    col1, col2 = st.columns([2, 1])
+
+    # --- LEFT COLUMN: Lesson content ---
+    with col1:
+        topics = lesson.get("topics", [])
+        if "current_topic" not in st.session_state:
+            st.session_state.current_topic = 1
+
+        # Clamp to valid range in case topics changed
+        st.session_state.current_topic = max(1, min(st.session_state.current_topic, len(topics)))
+        topic_idx = st.session_state.current_topic - 1
+        topic_name = topics[topic_idx]
+
+        # Track progress (max topic reached)
+        _mark_topic_seen(lesson["id"], st.session_state.current_topic)
+
+        st.subheader(f"Topic {st.session_state.current_topic}: {topic_name}")
+
+        # --- Special handling for Play / Quiz / Normal ---
+        if topic_name.lower().startswith("play"):
+            st.info("🎮 This is a game-based activity to reinforce learning.")
+            st.write("👉 Instructions on how to play go here.")
+            if st.button("▶ Play Game", key=f"play_game_{lesson['id']}_{topic_idx}"):
+                st.markdown(
+                    '<a href="http://your-game-url.com" target="_blank">Open Game in New Tab</a>',
+                    unsafe_allow_html=True
+                )
+
+        elif "quiz" in topic_name.lower():
+            st.info("📝 Time for a quick quiz!")
+            st.write("👉 Answer the following questions to test your knowledge.")
+            answer = st.radio("Q1. What is money?", ["Coins", "Bananas", "Shoes"])
+            if st.button("Submit Answer", key=f"quiz_submit_{lesson['id']}_{topic_idx}"):
+                if answer == "Coins":
+                    st.success("✅ Correct!")
+                else:
+                    st.error("❌ Try again.")
+        else:
+            content = load_topic_content(lesson["id"], st.session_state.current_topic)
+            st.markdown(f"""
+            <div class="topic-content">
+                {content}
+            </div>
+            """, unsafe_allow_html=True)
+
+        # Topic navigation buttons
+        prev_col, next_col = st.columns([1, 1])
+
+        with prev_col:
+            st.markdown("<div class='topic-nav-btn prev-btn'>", unsafe_allow_html=True)
+            if st.session_state.current_topic > 1:
+                if st.button("⬅ Previous Topic", key=f"prev_topic_{lesson['id']}", type="secondary"):
+                    st.session_state.current_topic -= 1
+                    st.rerun()
+            st.markdown("</div>", unsafe_allow_html=True)
+
+        with next_col:
+            st.markdown("<div class='topic-nav-btn next-btn'>", unsafe_allow_html=True)
+            is_last_topic = (st.session_state.current_topic >= len(topics))
+
+            if not is_last_topic:
+                # Normal next
+                if st.button("Next Topic ➡", key=f"next_topic_{lesson['id']}", type="primary"):
+                    st.session_state.current_topic += 1
+                    st.rerun()
+            else:
+                # 🔥 Replace Next with Complete on the last topic
+                if not _is_lesson_completed(lesson["id"]):
+                    if st.button("✅ Complete Module", key=f"complete_{lesson['id']}", type="primary"):
+                        _complete_lesson(lesson)
+                        st.success("🎉 Module completed! Great job.")
+                        # After completion, bounce back to lessons
+                        st.session_state.selected_lesson = None
+                        st.session_state.current_topic = 1
+                        st.session_state.start_lesson = False
+                        st.rerun()
+                else:
+                    st.button("✅ Completed", key=f"completed_{lesson['id']}", disabled=True)
+            st.markdown("</div>", unsafe_allow_html=True)
+
+
+    # --- RIGHT COLUMN: Progress + Lesson navigation ---
+    with col2:
+        st.subheader("📊 Progress")
+        _ensure_progress_state()
+        topics_count = max(1, len(lesson.get("topics", [])))
+        seen = st.session_state.topic_progress.get(lesson["id"], 0)
+        # progress is capped at total topics, and if marked complete, force to full
+        if _is_lesson_completed(lesson["id"]):
+            pct = 1.0
+        else:
+            pct = min(seen / topics_count, 1.0)
+        st.progress(pct)
+
+        st.subheader("➡ Lesson Navigation")
+        idx = next((i for i, l in enumerate(lessons) if l["id"] == lesson["id"]), 0)
+
+        if idx > 0:
+            if st.button("⬅ Previous Lesson", key=f"prev_lesson_{lesson['id']}"):
+                st.session_state.selected_lesson = lessons[idx - 1]["id"]
+                st.session_state.current_topic = 1
+                st.rerun()
+
+        if idx < len(lessons) - 1:
+            if st.button("Next Lesson ➡", key=f"next_lesson_{lesson['id']}"):
+                st.session_state.selected_lesson = lessons[idx + 1]["id"]
+                st.session_state.current_topic = 1
+                st.rerun()
+
+
+    st.markdown("---")
+   
+
+def render_assigned_lesson(lesson_id: int, assignment_id: int | None = None):
+    """Render a teacher-assigned lesson from the DB using the SAME structure/CSS as general lessons."""
+    user = st.session_state.user
+    user_id = user["user_id"]
+
+    data = dbapi.get_lesson(lesson_id)   # {"lesson": {...}, "sections":[...] }
+    if not data or not data.get("lesson"):
+        st.error("Lesson not found.")
+        if st.button("⬅ Back to classes"):
+            st.session_state.current_page = "Teacher Link"
+            st.rerun()
+        return
+
+    L = data["lesson"]
+    sections = sorted(data.get("sections", []), key=lambda s: int(s.get("position", 0)))
+    # 👉 adapt to the same card/page structure used by general lessons
+    lesson = _db_to_general_lesson_shape(L, sections)
+
+    # initialization flags (mirror general flow)
+    if "start_lesson" not in st.session_state:
+        st.session_state.start_lesson = False
+    if "selected_lesson" not in st.session_state:
+        st.session_state.selected_lesson = lesson["id"]
+
+    # Show like general: first a detail screen with Start, then topic pages
+    if st.session_state.start_lesson:
+        show_db_lesson_page(lesson)
+    else:
+        show_db_lesson_detail(lesson)
+
+
+def show_db_lesson_detail(lesson):
+    # Same header + objectives block as your general detail view
+    st.markdown(f"""
+        <h1 style="font-size:2.5rem; margin-bottom:0;">{lesson['title']}</h1>
+        <p style="color: #666; margin-top:0;">{lesson['duration']} &nbsp;•&nbsp; Module &nbsp;•&nbsp; {len(lesson.get("topics", []))} units</p>
+        <hr style="margin:1rem 0;"/>
+    """, unsafe_allow_html=True)
+
+    st.subheader("Learning objectives")
+    st.markdown("<p style='color:#888;margin-bottom:.5rem;'>In this module, you'll</p>", unsafe_allow_html=True)
+    st.markdown(
+        "- Focus on: Key ideas from this lesson  \n"
+        "- Build understanding step by step  \n"
+        "- Practice and check your knowledge"
+    )
+
+    if st.button("▶ Start", key=f"db_start_{lesson['id']}", type="primary"):
+        st.session_state.start_lesson = True
+        st.session_state.current_topic = 1
+        _ensure_progress_state()
+        if not _is_lesson_completed(lesson["id"]):
+            st.session_state.topic_progress[lesson["id"]] = 1
+        st.rerun()
+
+    st.markdown("---")
+
+    st.subheader("Topics")
+    for i, t in enumerate(lesson.get("topics", []), start=1):
+        st.markdown(f"- [{t}](#topic-{i})")
+
+    st.markdown("---")
+
+    if st.button("⬅ Back to Lessons", key=f"db_back_detail_{lesson['id']}"):
+        st.session_state.selected_lesson = None
+        st.rerun()
+
+
+def show_db_lesson_page(lesson):
+    # Back link – same as general
+    if st.button("⬅ Back to Lessons", key=f"db_back_top_{lesson['id']}"):
+        st.session_state.selected_lesson = None
+        st.session_state.current_topic = 1
+        st.session_state.current_lesson = None
+        st.session_state.start_lesson = False
+        st.rerun()
+
+    # Header – same gradient & chips
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg,#20c997,#17a2b8); padding: 1.5rem; border-radius: 12px; color: white; margin-bottom: 2rem;">
+        <h2 style="margin:0;">{lesson['title']}</h2>
+        <p style="margin:.3rem 0;">{lesson['description']}</p>
+        <div style="margin-top:.5rem;">
+            <span style="background:#ffffff22;padding:6px 12px;border-radius:6px;margin-right:6px;">⏱ {lesson['duration']}</span>
+            <span style="background:#ffffff22;padding:6px 12px;border-radius:6px;margin-right:6px;">📘 Module {lesson['id']}</span>
+            <span style="background:#ffffff22;padding:6px 12px;border-radius:6px;">⭐ {lesson['difficulty']}</span>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Layout
+    col1, col2 = st.columns([2, 1])
+
+    # LEFT: topic content (pulled from DB sections)
+    with col1:
+        topics = lesson.get("topics", [])
+        sections = lesson.get("_db_sections", [])
+        if "current_topic" not in st.session_state:
+            st.session_state.current_topic = 1
+
+        st.session_state.current_topic = max(1, min(st.session_state.current_topic, len(topics)))
+        idx = st.session_state.current_topic - 1
+        topic_name = topics[idx]
+        _mark_topic_seen(lesson["id"], st.session_state.current_topic)
+
+        st.subheader(f"Topic {st.session_state.current_topic}: {topic_name}")
+
+        # Same content container + CSS class as general
+        body = (sections[idx].get("content") or "⚠️ Topic content not available.")
+        st.markdown(f"<div class='topic-content'>{body}</div>", unsafe_allow_html=True)
+
+        # Prev/Next / Complete – identical logic
+        prev_col, next_col = st.columns([1, 1])
+        with prev_col:
+            st.markdown("<div class='topic-nav-btn prev-btn'>", unsafe_allow_html=True)
+            if st.session_state.current_topic > 1:
+                if st.button("⬅ Previous Topic", key=f"db_prev_topic_{lesson['id']}", type="secondary"):
+                    st.session_state.current_topic -= 1
+                    st.rerun()
+            st.markdown("</div>", unsafe_allow_html=True)
+
+        with next_col:
+            st.markdown("<div class='topic-nav-btn next-btn'>", unsafe_allow_html=True)
+            is_last = (st.session_state.current_topic >= len(topics))
+            if not is_last:
+                if st.button("Next Topic ➡", key=f"db_next_topic_{lesson['id']}", type="primary"):
+                    st.session_state.current_topic += 1
+                    st.rerun()
+            else:
+                if not _is_lesson_completed(lesson["id"]):
+                    if st.button("✅ Complete Module", key=f"db_complete_{lesson['id']}", type="primary"):
+                        _complete_lesson(lesson)
+                        st.success("🎉 Module completed! Great job.")
+                        st.session_state.selected_lesson = None
+                        st.session_state.current_topic = 1
+                        st.session_state.start_lesson = False
+                        st.rerun()
+                else:
+                    st.button("✅ Completed", key=f"db_completed_{lesson['id']}", disabled=True)
+            st.markdown("</div>", unsafe_allow_html=True)
+
+    # RIGHT: progress + lesson navigation – same UI
+    with col2:
+        st.subheader("📊 Progress")
+        _ensure_progress_state()
+        topics_count = max(1, len(lesson.get("topics", [])))
+        seen = st.session_state.topic_progress.get(lesson["id"], 0)
+        pct = 1.0 if _is_lesson_completed(lesson["id"]) else min(seen / topics_count, 1.0)
+        st.progress(pct)
+
+        st.subheader("➡ Lesson Navigation")
+        # For DB lessons, we don’t have a linear list like catalog; just basic controls
+        if st.button("⬅ Back to Lessons", key=f"db_back_side_{lesson['id']}"):
+            st.session_state.selected_lesson = None
+            st.session_state.current_topic = 1
+            st.rerun()
+
+    st.markdown("---")
+
+
+def show_page():
+    # Load CSS
+    css_path = os.path.join("assets", "styles.css")
+    load_css(css_path)
+
+    st.markdown("""<style> .markdown { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; line-height: 1.6;} </style>""", unsafe_allow_html=True)
+
+    # Check login
+    if not st.session_state.get("user"):
+        st.error("❌ Please login first to access lessons.")
+        st.info("💡 Create an account to track your progress and unlock advanced content!")
+        return
+
+    user = st.session_state.user
+    user_level = user.get("level", "beginner").lower()
+
+    # Deep link from Teacher Link: if a selected_lesson isn't in the catalog,
+    # render it from the DB instead.
+    deep_lesson_id = st.session_state.get("selected_lesson")
+    deep_assignment_id = st.session_state.get("selected_assignment")
+
+    # Try to resolve in catalog first
+    lessons = lessons_by_level.get(user_level, [])
+    catalog_ids = {l["id"] for l in lessons}
+
+    if deep_lesson_id and deep_lesson_id not in catalog_ids:
+        # 👉 This is a teacher-assigned(DB) lesson. Open it directly.
+        render_assigned_lesson(int(deep_lesson_id), deep_assignment_id)
+        return
+
+    # Initialize session state
+    if "selected_lesson" not in st.session_state:
+        st.session_state.selected_lesson = None
+    if "start_lesson" not in st.session_state:
+        st.session_state.start_lesson = False
+
+    # If a lesson is selected
+    if st.session_state.selected_lesson:
+        lesson = next((l for l in lessons if l["id"] == st.session_state.selected_lesson), None)
+        if lesson:
+            if st.session_state.start_lesson:  # 🚀 Jump straight into topics
+                show_lesson_page(lesson, lessons)
+            else:
+                show_lesson_detail(lesson)
+        else:
+            st.warning("⚠️ Lesson not found")
+    else:
+        # Otherwise → show lesson cards
+        show_lesson_cards(lessons, user_level)

phase/Student_view/lessons/lesson_1/topic_1.txt

@@ -0,0 +1,7 @@
+Money is something we use to buy things we need or want, like food, toys, or clothes. 
+
+In Jamaica, money comes in different forms: 
+- coins, which are small metal pieces like the shiny 1-dollar or 5-dollar coins
+- notes, which are colorful paper bills such as the 50-dollar or 100-dollar notes featuring pictures of Jamaican heroes. 
+
+There's also digital money, which is like invisible money stored on cards or phones that you can use to pay without touching cash, for example, when parents use their phone to buy groceries at the supermarket.

phase/Student_view/quiz.py

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

phase/Student_view/teacherlink.py

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

phase/Teacher_view/classmanage.py

@@ -0,0 +1,125 @@
+# phase/Teacher_view/classmanage.py
+
+import streamlit as st
+import random
+import string
+from datetime import datetime
+from utils import db as dbapi
+
+def _metric_card(label: str, value: str, caption: str = ""):
+    st.markdown(
+        f"""
+        <div class="metric-card">
+          <div class="metric-value">{value}</div>
+          <div class="metric-label">{label}</div>
+          <div class="metric-caption">{caption}</div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+def show_page():
+    user = st.session_state.user
+    teacher_id = user["user_id"]
+
+    st.title("📚 Classroom Management")
+    st.caption("Manage all your classrooms and students")
+
+    # -------- Create Classroom --------
+    with st.expander("➕ Create Classroom", expanded=False):
+        new_name = st.text_input("Classroom Name", key="new_classroom_name")
+        if st.button("Create Classroom"):
+            name = new_name.strip()
+            if name:
+                out = dbapi.create_class(teacher_id, name)
+                st.session_state.selected_class_id = out["class_id"]
+                st.success(f'Classroom "{name}" created with code: {out["code"]}')
+                st.rerun()
+            else:
+                st.error("Enter a real name, not whitespace.")
+
+    # -------- Load classes for this teacher --------
+    classes = dbapi.list_classes_by_teacher(teacher_id)
+    if not classes:
+        st.info("No classrooms yet. Create one above, then share the code.")
+        return
+
+    # Picker like your mock header bar
+    st.subheader("Your Classrooms")
+    options = {f"{c['name']} (Code: {c.get('code','')})": c for c in classes}
+    selected_label = st.selectbox("Select a classroom", list(options.keys()))
+    selected = options[selected_label]
+    class_id = selected["class_id"]
+
+    st.markdown("---")
+    st.header(selected["name"])
+
+    # -------- Code stripe --------
+    st.subheader("Class Code")
+    c1, c2, c3 = st.columns([3, 1, 1])
+    with c1:
+        st.markdown(f"**`{selected.get('code', 'UNKNOWN')}`**")
+    with c2:
+        if st.button("📋 Copy Code"):
+            st.toast("Code is shown above. Copy it.")
+    with c3:
+        st.button("🗑️ Delete Class", disabled=True, help="Soft-delete coming later")
+
+    # -------- Tabs --------
+    tab_students, tab_content, tab_analytics = st.tabs(["👥 Students", "📘 Content", "📊 Analytics"])
+
+    # ============== Students tab ==============
+    with tab_students:
+        # search input
+        q = st.text_input("Search students by name or email", "")
+        roster = dbapi.list_students_in_class(class_id)
+
+        # simple filter
+        if q.strip():
+            ql = q.lower()
+            roster = [r for r in roster if ql in r["name"].lower() or ql in r["email"].lower()]
+
+        st.caption(f"{len(roster)} Students Found")
+
+        if not roster:
+            st.info("No students in this class yet.")
+        else:
+            for s in roster:
+                st.subheader(f"👤 {s['name']}")
+                st.caption(s["email"])
+                joined = s.get("joined_at") or s.get("created_at")
+                st.caption(f"📅 Joined: {str(joined)[:10]}")
+                st.progress(0.0)  # placeholder bar to match your style
+                cols = st.columns(3)
+                cols[0].metric("⭐ Level", s["level_slug"].capitalize())
+                cols[1].metric("📊 Avg Score", "—")    # can be filled per-student later
+                cols[2].metric("🔥 Streak", "—")       # from streaks table if you want
+                st.markdown("---")
+
+    # ============== Content tab ==============
+    with tab_content:
+        counts = dbapi.class_content_counts(class_id)
+        left, right = st.columns(2)
+        with left:
+            _metric_card("📖 Custom Lessons", str(counts["lessons"]), "Lessons created for this classroom")
+        with right:
+            _metric_card("🏆 Custom Quizzes", str(counts["quizzes"]), "Quizzes created for this classroom")
+
+        # Optional list so teachers know what those numbers are
+        assigs = dbapi.list_class_assignments(class_id)
+        if assigs:
+            st.markdown("#### Assigned items")
+            for a in assigs:
+                has_quiz = " + Quiz" if a["quiz_id"] else ""
+                st.markdown(f"- **{a['title']}** · {a['subject']} · {a['level']}{has_quiz}")
+
+    # ============== Analytics tab ==============
+    with tab_analytics:
+        stats = dbapi.class_analytics(class_id)
+        g1, g2, g3 = st.columns(3)
+        with g1:
+            _metric_card("📊 Class Average", f"{round(stats['class_avg']*100)}%", "Average quiz performance")
+        with g2:
+            _metric_card("🪙 Total XP", f"{stats['total_xp']}", "Combined XP earned")
+        with g3:
+            _metric_card("📘 Lessons Completed", f"{stats['lessons_completed']}", "Total lessons completed")

phase/Teacher_view/contentmanage.py

@@ -0,0 +1,618 @@
+# phase/Teacher_view/contentmanage.py
+import json
+import streamlit as st
+from datetime import datetime
+from utils import db as dbapi
+
+# ---------- small UI helpers ----------
+def _pill(text):
+    return f"<span style='background:#eef6ff;border:1px solid #cfe3ff;border-radius:999px;padding:2px 8px;font-size:12px;margin-right:6px'>{text}</span>"
+
+def _progress(val: float):
+    pct = max(0, min(100, int(round(val * 100))))
+    return f"""
+    <div style="height:8px;background:#eef2ff;border-radius:999px;overflow:hidden">
+      <div style="width:{pct}%;height:100%;background:#3b82f6"></div>
+    </div>
+    """
+
+
+# ---------- OpenAI quiz generator ----------
+def _generate_quiz_from_text(content: str, n_questions: int = 5):
+    """
+    Returns a list of dicts like:
+      {"question": "...", "options": ["A","B","C","D"], "answer_key": "B", "points": 1}
+    Uses OPENAI_API_KEY from your env.
+    """
+    system = (
+        "You are a Jamaican primary school financial literacy teacher. "
+        "Write clear multiple-choice questions (A-D) about the provided lesson content. "
+        "Keep language simple and age-appropriate. Only one correct answer per question."
+    )
+    user = (
+        f"Create {n_questions} MCQs strictly in this JSON format:\n"
+        "{\n"
+        '  \"items\":[\n'
+        '    {\"question\":\"...\", \"options\":[\"A\",\"B\",\"C\",\"D\"], \"answer_key\":\"A\"}\n'
+        "  ]\n"
+        "}\n\n"
+        "Lesson content:\n"
+        f"{content}"
+    )
+
+    def _normalize(items):
+        out = []
+        for it in (items or [])[:n_questions]:
+            q = str(it.get("question", "")).strip()
+            opts = it.get("options", [])
+            if not q or not isinstance(opts, list) or len(opts) < 2:
+                continue
+            while len(opts) < 4:
+                opts.append("Option")
+            opts = opts[:4]
+            key = str(it.get("answer_key", "A")).strip().upper()[:1]
+            if key not in ("A","B","C","D"):
+                key = "A"
+            out.append({"question": q, "options": opts, "answer_key": key, "points": 1})
+        return out
+
+    try:
+        from openai import OpenAI
+        client = OpenAI()
+
+        # 1) Preferred path: Responses API
+        try:
+            resp = client.responses.create(
+                model="gpt-4o-mini",
+                temperature=0.2,
+                response_format={"type": "json_object"},
+                input=[
+                    {"role": "system", "content": [{"type": "text", "text": system}]},
+                    {"role": "user",   "content": [{"type": "text", "text": user}]},
+                ],
+            )
+            raw = getattr(resp, "output_text", "") or ""
+            data = json.loads(raw)
+            return _normalize(data.get("items", []))
+
+        # 2) Fallback: Chat Completions
+        except Exception:
+            resp = client.chat.completions.create(
+                model="gpt-4o-mini",
+                temperature=0.2,
+                messages=[{"role":"system","content":system},{"role":"user","content":user}],
+                response_format={"type": "json_object"},
+            )
+            raw = resp.choices[0].message.content.strip()
+            data = json.loads(raw)
+            return _normalize(data.get("items", []))
+
+    except Exception as e:
+        with st.expander("Quiz generation error details"):
+            st.code(str(e))
+        st.warning("Quiz generation failed. Check API key and your openai package version.")
+        return []
+
+# ---------- Create panels ----------
+def _create_lesson_panel(teacher_id: int):
+    st.markdown("### ✍️ Create New Lesson")
+
+    classes = dbapi.list_classes_by_teacher(teacher_id)
+    class_opts = {f"{c['name']} (code {c['code']})": c["class_id"] for c in classes} if classes else {}
+
+    if "cl_topic_count" not in st.session_state:
+        st.session_state.cl_topic_count = 2  # start with two topics
+
+    # UI-manipulation buttons OUTSIDE the form
+    cols_btn = st.columns([1,1,6])
+    with cols_btn[0]:
+        if st.button("➕ Add topic", type="secondary"):
+            st.session_state.cl_topic_count = min(20, st.session_state.cl_topic_count + 1)
+            st.rerun()
+    with cols_btn[1]:
+        if st.button("➖ Remove last", type="secondary", disabled=st.session_state.cl_topic_count <= 1):
+            st.session_state.cl_topic_count = max(1, st.session_state.cl_topic_count - 1)
+            st.rerun()
+
+    with st.form("create_lesson_form", clear_on_submit=False):
+        c1, c2 = st.columns([2,1])
+        title = c1.text_input("Title", placeholder="e.g., Jamaican Money Recognition")
+        level = c2.selectbox("Level", ["beginner","intermediate","advanced"], index=0)
+        description = st.text_area("Short description")
+        subject = st.selectbox("Subject", ["numeracy","finance"], index=0)
+
+        st.markdown("#### Topics")
+        topic_rows = []
+        for i in range(1, st.session_state.cl_topic_count + 1):
+            with st.expander(f"Topic {i}", expanded=True if i <= 2 else False):
+                t = st.text_input(f"Topic {i} title", key=f"t_title_{i}")
+                b = st.text_area(f"Topic {i} content", key=f"t_body_{i}", height=150)
+                topic_rows.append((t, b))
+
+        add_summary = st.checkbox("Append a Summary section at the end", value=True)
+        summary_text = ""
+        if add_summary:
+            summary_text = st.text_area(
+                "Summary notes",
+                key="summary_notes",
+                height=120,
+                placeholder="Key ideas, local examples, common mistakes, quick recap..."
+            )
+
+        st.markdown("#### Assign to class (optional)")
+        assign_classes = st.multiselect("Choose one or more classes", list(class_opts.keys()))
+
+        st.markdown("#### Auto-generate a quiz from this lesson (optional)")
+        gen_quiz = st.checkbox("Generate a quiz from content", value=False)
+        q_count = st.slider("", 3, 10, 5)  # label empty because already described
+        
+        # ONLY keep the main submit button inside the form
+        submitted = st.form_submit_button("Create lesson", type="primary")
+
+
+    if not submitted:
+        return
+
+    # build sections payload for DB
+    sections = []
+    for t, b in topic_rows:
+        if (t or b):
+            sections.append({"title": t or "Topic", "content": b or ""})
+
+    if add_summary:
+        sections.append({
+            "title": "Summary",
+            "content": (summary_text or "Write a short recap of the most important ideas.").strip()
+        })
+
+    if not title or not sections:
+        st.error("Please add a title and at least one topic.")
+        return
+
+    # create lesson
+    lesson_id = dbapi.create_lesson(teacher_id, title, description, subject, level, sections)
+    st.success(f"✅ Lesson created (ID {lesson_id}).")
+
+    # assign to chosen classes (lesson only for now)
+    for label in assign_classes:
+        dbapi.assign_to_class(lesson_id, None, class_opts[label], teacher_id)
+
+    # auto-generate quiz
+    if gen_quiz:
+        text = "\n\n".join([s["title"] + "\n" + (s["content"] or "") for s in sections])
+        with st.spinner("Generating quiz..."):
+            items = _generate_quiz_from_text(text, n_questions=q_count)
+        if items:
+            qid = dbapi.create_quiz(lesson_id, f"{title} - Quiz", items, {})
+            st.success(f"🧠 Quiz generated and saved (ID {qid}).")
+            for label in assign_classes:
+                dbapi.assign_to_class(lesson_id, qid, class_opts[label], teacher_id)
+
+    st.session_state.show_create_lesson = False
+    st.rerun()
+
+
+
+def _create_quiz_panel(teacher_id: int):
+    st.markdown("### 🏆 Create New Quiz")
+
+    # teacher lessons to link
+    lessons = dbapi.list_lessons_by_teacher(teacher_id)
+    lesson_map = {f"{L['title']} (#{L['lesson_id']})": L["lesson_id"] for L in lessons}
+    if not lesson_map:
+        st.info("Create a lesson first, then link a quiz to it.")
+        return
+
+    # dynamic questions
+    if "cq_q_count" not in st.session_state:
+        st.session_state.cq_q_count = 5
+
+    with st.form("create_quiz_form", clear_on_submit=False):
+        c1, c2 = st.columns([2,1])
+        title = c1.text_input("Title", placeholder="e.g., Currency Basics Quiz")
+        lesson_label = c2.selectbox("Linked Lesson", list(lesson_map.keys()))
+
+        st.markdown("#### Questions (up to 10)")
+        items = []
+        for i in range(1, st.session_state.cq_q_count + 1):
+            with st.expander(f"Question {i}", expanded=(i <= 2)):
+                q = st.text_area(f"Prompt {i}", key=f"q_{i}")
+                cA, cB = st.columns(2)
+                a = cA.text_input(f"Option A (correct?)", key=f"optA_{i}")
+                b = cB.text_input(f"Option B", key=f"optB_{i}")
+                cC, cD = st.columns(2)
+                c = cC.text_input(f"Option C", key=f"optC_{i}")
+                d = cD.text_input(f"Option D", key=f"optD_{i}")
+                correct = st.radio("Correct answer", ["A","B","C","D"], index=0, key=f"ans_{i}", horizontal=True)
+                items.append({"question": q, "options": [a,b,c,d], "answer_key": correct, "points": 1})
+
+        row = st.columns([1,1,4,2])
+        with row[0]:
+            if st.form_submit_button("➕ Add question", type="secondary", disabled=st.session_state.cq_q_count >= 10):
+                st.session_state.cq_q_count = min(10, st.session_state.cq_q_count + 1)
+                st.rerun()
+        with row[1]:
+            if st.form_submit_button("➖ Remove last", type="secondary", disabled=st.session_state.cq_q_count <= 1):
+                st.session_state.cq_q_count = max(1, st.session_state.cq_q_count - 1)
+                st.rerun()
+
+        submitted = row[3].form_submit_button("Create quiz", type="primary")
+
+    if not submitted:
+        return
+    if not title:
+        st.error("Please add a quiz title.")
+        return
+
+    # sanitize items
+    cleaned = []
+    for it in items:
+        q = (it["question"] or "").strip()
+        opts = [o for o in it["options"] if (o or "").strip()]
+        if len(opts) < 2 or not q:
+            continue
+        while len(opts) < 4:
+            opts.append("Option")
+        cleaned.append({"question": q, "options": opts[:4], "answer_key": it["answer_key"], "points": 1})
+
+    if not cleaned:
+        st.error("Add at least one valid question.")
+        return
+
+    qid = dbapi.create_quiz(lesson_map[lesson_label], title, cleaned, {})
+    st.success(f"✅ Quiz created (ID {qid}).")
+
+    st.session_state.show_create_quiz = False
+    st.rerun()
+
+
+def _edit_lesson_panel(teacher_id: int, lesson_id: int):
+    data = dbapi.get_lesson(lesson_id)
+    L = data["lesson"]
+    secs = data["sections"] or []
+
+    key_cnt = f"el_cnt_{lesson_id}"
+    if key_cnt not in st.session_state:
+        st.session_state[key_cnt] = max(1, len(secs))
+
+    st.markdown("### ✏️ Edit Lesson")
+
+    #Move UI-manipulation buttons 
+    tools = st.columns([1,1,8])
+    with tools[0]:
+        if st.button("➕ Add section", key=f"el_add_{lesson_id}", use_container_width=True):
+            st.session_state[key_cnt] = min(50, st.session_state[key_cnt] + 1)
+            st.rerun()
+    with tools[1]:
+        if st.button("➖ Remove last", key=f"el_rem_{lesson_id}",
+                     disabled=st.session_state[key_cnt] <= 1, use_container_width=True):
+            st.session_state[key_cnt] = max(1, st.session_state[key_cnt] - 1)
+            st.rerun()
+
+    #  The form only has fields + a single submit (Save)
+    with st.form(f"edit_lesson_form_{lesson_id}", clear_on_submit=False):
+        c1, c2 = st.columns([2,1])
+        title = c1.text_input("Title", value=L["title"])
+        level = c2.selectbox(
+            "Level",
+            ["beginner","intermediate","advanced"],
+            index=["beginner","intermediate","advanced"].index(L["level"])
+        )
+        description = st.text_area("Short description", value=L.get("description") or "")
+        subject = st.selectbox("Subject", ["numeracy","finance"], index=(0 if L["subject"]=="numeracy" else 1))
+
+        st.markdown("#### Sections")
+        edited_sections = []
+        total = st.session_state[key_cnt]
+        for i in range(1, total + 1):
+            s = secs[i-1] if i-1 < len(secs) else {"title":"", "content":""}
+            with st.expander(f"Section {i}", expanded=(i <= 2)):
+                t = st.text_input(f"Title {i}", value=s.get("title") or "", key=f"el_t_{lesson_id}_{i}")
+                b = st.text_area(f"Content {i}", value=s.get("content") or "", height=150, key=f"el_b_{lesson_id}_{i}")
+                edited_sections.append({"title": t or "Section", "content": b or ""})
+
+        save = st.form_submit_button("💾 Save changes", type="primary", use_container_width=True)
+
+    # Cancel is a normal button outside the form
+    actions = st.columns([8,2])
+    with actions[1]:
+        cancel_clicked = st.button("✖ Cancel", key=f"el_cancel_{lesson_id}", type="secondary", use_container_width=True)
+
+    if cancel_clicked:
+        st.session_state.show_edit_lesson = False
+        st.session_state.edit_lesson_id = None
+        st.rerun()
+
+    if not save:
+        return
+
+    # validation + persist
+    if not title or not any((s["title"] or s["content"]).strip() for s in edited_sections):
+        st.error("Title and at least one non-empty section are required.")
+        return
+
+    ok = dbapi.update_lesson(lesson_id, teacher_id, title, description, subject, level, edited_sections)
+    if ok:
+        st.success("✅ Lesson updated.")
+        st.session_state.show_edit_lesson = False
+        st.session_state.edit_lesson_id = None
+        st.rerun()
+    else:
+        st.error("Could not update this lesson. Check ownership or DB errors.")
+
+
+def _edit_quiz_panel(teacher_id: int, quiz_id: int):
+    data = dbapi.get_quiz(quiz_id)  # {'quiz': {...}, 'items': [...]}
+    if not data or not data.get("quiz"):
+        st.error("Quiz not found.")
+        return
+
+    Q = data["quiz"]
+    raw_items = data.get("items", [])
+
+    def _dec(x):
+        if isinstance(x, str):
+            try:
+                return json.loads(x)
+            except Exception:
+                return x
+        return x
+
+    # Normalize into simple dicts that the form can bind to
+    items = []
+    for it in raw_items:
+        opts = _dec(it.get("options")) or []
+        while len(opts) < 4:
+            opts.append("Option")
+        opts = opts[:4]
+
+        ans = _dec(it.get("answer_key"))
+        if isinstance(ans, list) and ans:
+            ans = ans[0]
+        ans = (str(ans) or "A").upper()[:1]
+        if ans not in ("A","B","C","D"):
+            ans = "A"
+
+        items.append({
+            "question": (it.get("question") or "").strip(),
+            "options": opts,
+            "answer_key": ans,
+            "points": int(it.get("points") or 1),
+        })
+
+    key_cnt = f"eq_cnt_{quiz_id}"
+    if key_cnt not in st.session_state:
+        st.session_state[key_cnt] = max(1, len(items) or 5)
+
+    st.markdown("### ✏️ Edit Quiz")
+
+    with st.form(f"edit_quiz_form_{quiz_id}", clear_on_submit=False):
+        title = st.text_input("Title", value=Q.get("title") or f"Quiz #{quiz_id}")
+
+        edited = []
+        total = st.session_state[key_cnt]
+        for i in range(1, total + 1):
+            it = items[i-1] if i-1 < len(items) else {"question":"", "options":["","","",""], "answer_key":"A", "points":1}
+            with st.expander(f"Question {i}", expanded=(i <= 2)):
+                q = st.text_area(f"Prompt {i}", value=it["question"], key=f"eq_q_{quiz_id}_{i}")
+                cA, cB = st.columns(2)
+                a = cA.text_input(f"Option A", value=it["options"][0], key=f"eq_A_{quiz_id}_{i}")
+                b = cB.text_input(f"Option B", value=it["options"][1], key=f"eq_B_{quiz_id}_{i}")
+                cC, cD = st.columns(2)
+                c = cC.text_input(f"Option C", value=it["options"][2], key=f"eq_C_{quiz_id}_{i}")
+                d = cD.text_input(f"Option D", value=it["options"][3], key=f"eq_D_{quiz_id}_{i}")
+                correct = st.radio("Correct answer", ["A","B","C","D"],
+                                   index=["A","B","C","D"].index(it["answer_key"]),
+                                   key=f"eq_ans_{quiz_id}_{i}", horizontal=True)
+                edited.append({"question": q, "options": [a,b,c,d], "answer_key": correct, "points": 1})
+
+        row = st.columns([1,1,6,2,2])
+        with row[0]:
+            if st.form_submit_button("➕ Add question", type="secondary"):
+                st.session_state[key_cnt] = min(20, st.session_state[key_cnt] + 1)
+                st.rerun()
+        with row[1]:
+            if st.form_submit_button("➖ Remove last", type="secondary", disabled=st.session_state[key_cnt] <= 1):
+                st.session_state[key_cnt] = max(1, st.session_state[key_cnt] - 1)
+                st.rerun()
+
+        save = row[3].form_submit_button("💾 Save", type="primary")
+        cancel = row[4].form_submit_button("✖ Cancel", type="secondary")
+
+    if cancel:
+        st.session_state.show_edit_quiz = False
+        st.session_state.edit_quiz_id = None
+        st.rerun()
+
+    if not save:
+        return
+
+    # sanitize
+    cleaned = []
+    for it in edited:
+        q = (it["question"] or "").strip()
+        opts = [o for o in it["options"] if (o or "").strip()]
+        if not q or len(opts) < 2:
+            continue
+        while len(opts) < 4:
+            opts.append("Option")
+        cleaned.append({
+            "question": q,
+            "options": opts[:4],
+            "answer_key": it["answer_key"],  # single letter
+            "points": 1
+        })
+
+    if not title or not cleaned:
+        st.error("Title and at least one valid question are required.")
+        return
+
+    ok = dbapi.update_quiz(quiz_id, teacher_id, title, cleaned, settings={})
+    if ok:
+        st.success("✅ Quiz updated.")
+        st.session_state.show_edit_quiz = False
+        st.session_state.edit_quiz_id = None
+        st.rerun()
+    else:
+        st.error("Could not update this quiz. Check ownership or DB errors.")
+
+
+# ---------- Main page ----------
+def show_page():
+    user = st.session_state.user
+    teacher_id = user["user_id"]
+
+    st.title("📚 Content Management")
+    st.caption("Create and manage custom lessons and quizzes")
+
+    # preload lists
+    lessons = dbapi.list_lessons_by_teacher(teacher_id)
+    quizzes = dbapi.list_quizzes_by_teacher(teacher_id)
+
+    # top action bar (no popovers)
+    a1, a2, _sp = st.columns([3,3,4])
+    if a1.button("➕ Create Lesson", use_container_width=True):
+        st.session_state.show_create_lesson = True
+    if a2.button("🏆 Create Quiz", use_container_width=True):
+        st.session_state.show_create_quiz = True
+
+    # big inline create panels
+    if st.session_state.get("show_create_lesson"):
+        with st.container(border=True):
+            _create_lesson_panel(teacher_id)
+        st.markdown("---")
+
+    if st.session_state.get("show_create_quiz"):
+        with st.container(border=True):
+            _create_quiz_panel(teacher_id)
+        st.markdown("---")
+
+    # ----- Inline lesson edit panel, when triggered -----
+    if st.session_state.get("show_edit_lesson") and st.session_state.get("edit_lesson_id"):
+        with st.container(border=True):
+            _edit_lesson_panel(teacher_id, st.session_state.edit_lesson_id)
+        st.markdown("---")
+    # ----- Inline quiz edit panel, when triggered -----
+    if st.session_state.get("show_edit_quiz") and st.session_state.get("edit_quiz_id"):
+        with st.container(border=True):
+            _edit_quiz_panel(teacher_id, st.session_state.edit_quiz_id)
+        st.markdown("---")
+
+
+    # Tabs
+    tab1, tab2 = st.tabs([f"Custom Lessons ({len(lessons)})", f"Custom Quizzes ({len(quizzes)})"])
+
+    # ========== LESSONS ==========
+    with tab1:
+        if not lessons:
+            st.info("No lessons yet. Use **Create Lesson** above.")
+        else:
+            # all students across teacher's classes (optional “assign to students” inline UI you already had)
+            all_students = dbapi.list_all_students_for_teacher(teacher_id)
+            student_options = {f"{s['name']} · {s['email']}": s["user_id"] for s in all_students}
+
+            for L in lessons:
+                assignees = dbapi.list_assigned_students_for_lesson(L["lesson_id"])
+                assignee_names = [a["name"] for a in assignees]
+                created = L["created_at"].strftime("%Y-%m-%d") if isinstance(L["created_at"], datetime) else str(L["created_at"])[:10]
+                count = len(assignees)
+
+                with st.container(border=True):
+                    c1, c2 = st.columns([8,3])
+                    with c1:
+                        st.markdown(f"### {L['title']}")
+                        st.caption(L.get("description") or "")
+                        st.markdown(
+                            _pill(L["level"].capitalize()) +
+                            _pill(L["subject"]) +
+                            _pill(f"{count} student{'s' if count != 1 else ''} assigned") +
+                            _pill(f"Created {created}"),
+                            unsafe_allow_html=True
+                        )
+                    with c2:
+                        b1, b2 = st.columns([1,1])
+                        with b1:
+                            if st.button("Edit", key=f"edit_{L['lesson_id']}"):
+                                st.session_state.edit_lesson_id = L["lesson_id"]
+                                st.session_state.show_edit_lesson = True
+                                st.rerun()
+                        with b2:
+                            if st.button("Delete", key=f"del_{L['lesson_id']}"):
+                                ok, msg = dbapi.delete_lesson(L["lesson_id"], teacher_id)
+                                if ok: st.success("Lesson deleted"); st.rerun()
+                                else:  st.error(msg)
+
+                    st.markdown("**Assigned Students:**")
+                    if assignee_names:
+                        st.markdown(" ".join(_pill(n) for n in assignee_names), unsafe_allow_html=True)
+                    else:
+                        st.caption("No students assigned yet.")
+
+    # ========== QUIZZES ==========
+    with tab2:
+        if not quizzes:
+            st.info("No quizzes yet. Use **Create Quiz** above.")
+        else:
+            for Q in quizzes:
+                assignees = dbapi.list_assigned_students_for_quiz(Q["quiz_id"])
+                created = Q["created_at"].strftime("%Y-%m-%d") if isinstance(Q["created_at"], datetime) else str(Q["created_at"])[:10]
+                num_qs = int(Q.get("num_items", 0))
+
+                with st.container(border=True):
+                    c1, c2 = st.columns([8,3])
+                    with c1:
+                        st.markdown(f"### {Q['title']}")
+                        st.caption(f"Lesson: {Q['lesson_title']}")
+                        st.markdown(
+                            _pill(f"{num_qs} question{'s' if num_qs != 1 else ''}") +
+                            _pill(f"{len(assignees)} students assigned") +
+                            _pill(f"Created {created}"),
+                            unsafe_allow_html=True
+                        )
+                    with c2:
+                        b1, b2 = st.columns(2)
+                        with b1:
+                            if st.button("Edit", key=f"editq_{Q['quiz_id']}"):
+                                st.session_state.edit_quiz_id = Q["quiz_id"]
+                                st.session_state.show_edit_quiz = True
+                                st.rerun()
+                        with b2:
+                            if st.button("Delete", key=f"delq_{Q['quiz_id']}"):
+                                ok, msg = dbapi.delete_quiz(Q["quiz_id"], teacher_id)
+                                if ok: st.success("Quiz deleted"); st.rerun()
+                                else:  st.error(msg)
+
+                    st.markdown("**Assigned Students:**")
+                    if assignees:
+                        st.markdown(" ".join(_pill(a['name']) for a in assignees), unsafe_allow_html=True)
+                    else:
+                        st.caption("No students assigned yet.")
+
+                    with st.expander("View questions", expanded=False):
+                        data = dbapi.get_quiz(Q["quiz_id"])  # {'quiz': {...}, 'items': [...]}
+                        items = data.get("items", []) if data else []
+                        if not items:
+                            st.info("No items found for this quiz.")
+                        else:
+                            labels = ["A","B","C","D"]
+                            for i, it in enumerate(items, start=1):
+                                # Handle JSON columns that may come back as strings
+                                opts = it.get("options")
+                                if isinstance(opts, str):
+                                    try:
+                                        opts = json.loads(opts)
+                                    except Exception:
+                                        opts = [opts]
+                                answer = it.get("answer_key")
+                                if isinstance(answer, str):
+                                    try:
+                                        answer = json.loads(answer)
+                                    except Exception:
+                                        pass
+
+                                st.markdown(f"**Q{i}.** {it.get('question','').strip()}")
+                                for j, opt in enumerate((opts or [])[:4]):
+                                    st.write(f"{labels[j]}) {opt}")
+                                ans_text = answer if isinstance(answer, str) else ",".join(answer or [])
+                                st.caption(f"Answer: {ans_text}")
+                                st.markdown("---")

phase/Teacher_view/studentlist.py

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