app.py

"""
Streamlit app for Hint-Based Math Tutor (Problem 13).
Single Tutor tab with V2 chained pipeline + history sidebar.
"""
import streamlit as st
import json
import os
import sys
import random
from typing import Optional
from datetime import datetime
from dotenv import load_dotenv

# Load .env from the package directory BEFORE importing modules that need it
_here = os.path.dirname(os.path.abspath(__file__))
load_dotenv(os.path.join(_here, ".env"))

sys.path.insert(0, _here)

from pipeline_v2 import (
    start_problem,
    get_hint,
    can_unlock_level3,
    analyze_working,
    generate_targeted_hint,
    get_debug_log,
)
from guardrails import input_gate_code, normalise_numeric_equal


st.set_page_config(page_title="Hint-Based Math Tutor", page_icon="🧮", layout="wide")


# --- Session State ---
if "tutor_state" not in st.session_state:
    st.session_state.tutor_state = {
        "problem": "",
        "solution": None,
        "refusal": None,
        "hints_shown": [],  # list of {level, hint, follow_up, guard_status, attempts}
        "shown_levels": set(),
        "attempts_made": 0,
        "working_analysis": None,
        "targeted_hint": None,
        "final_answer": "",
    }

if "history" not in st.session_state:
    st.session_state.history = []  # list of completed problem sessions


# Bank of 6 extra problems (NOT in eval)
EXTRA_PROBLEMS = [
    {
        "id": "extra_001",
        "text": "A bakery sold 24 cupcakes in the morning and 18 in the afternoon. Each cupcake costs $2.50. How much money did the bakery make?",
        "answer": "$105.00"
    },
    {
        "id": "extra_002",
        "text": "A rectangular garden is 15 meters long and 10 meters wide. What is its perimeter?",
        "answer": "50 meters"
    },
    {
        "id": "extra_003",
        "text": "Tom reads 12 pages per day. How many pages does he read in 3 weeks?",
        "answer": "252 pages"
    },
    {
        "id": "extra_004",
        "text": "A box contains 36 chocolates. If 4 friends share them equally, how many does each get?",
        "answer": "9 chocolates"
    },
    {
        "id": "extra_005",
        "text": "A car travels 240 km on 15 liters of fuel. How many km per liter does it get?",
        "answer": "16 km/L"
    },
    {
        "id": "extra_006",
        "text": "Lisa has 3 bags with 8 marbles each. She gives 5 marbles to her brother. How many marbles does she have left?",
        "answer": "19 marbles"
    },
]


# --- Helper Functions ---
def format_hint_card(level: int, hint_text: str, follow_up: Optional[str], guard_status: str, attempts: int):
    """Render a hint card with guard badge."""
    level_names = {1: "🎯 Level 1: Orient", 2: "🧭 Level 2: Strategy", 3: "📝 Level 3: Walkthrough"}
    badge_colors = {
        "passed": "🟢",
        "fallback": "🔴",
    }

    if guard_status.startswith("regenerated"):
        badge = f"🟡 Regenerated {guard_status.split('_')[1]}×"
    else:
        badge = f"{badge_colors.get(guard_status, '⚪')} {guard_status.capitalize()}"

    with st.container(border=True):
        st.markdown(f"### {level_names.get(level, f'Level {level}')}")
        st.markdown(f"**Guard:** {badge}")
        st.markdown(hint_text)
        if follow_up:
            st.info(f"💡 {follow_up}")


def reset_tutor():
    """Reset tutor state for a new problem, saving current to history."""
    state = st.session_state.tutor_state
    if state["problem"] and (state["hints_shown"] or state["working_analysis"] or state["final_answer"]):
        # Save to history
        history_entry = {
            "timestamp": datetime.now().strftime("%H:%M:%S"),
            "problem": state["problem"],
            "hints": state["hints_shown"].copy(),
            "working_analysis": state["working_analysis"],
            "targeted_hint": state["targeted_hint"],
            "final_answer": state["final_answer"],
            "solution_answer": state["solution"].final_answer if state["solution"] else None,
        }
        st.session_state.history.insert(0, history_entry)  # newest first

    # Reset tutor state
    st.session_state.tutor_state = {
        "problem": "",
        "solution": None,
        "refusal": None,
        "hints_shown": [],
        "shown_levels": set(),
        "attempts_made": 0,
        "working_analysis": None,
        "targeted_hint": None,
        "final_answer": "",
    }


def clear_history():
    """Clear the history sidebar."""
    st.session_state.history = []


def load_history_problem(index: int):
    """Load a problem from history back into the tutor."""
    if 0 <= index < len(st.session_state.history):
        entry = st.session_state.history[index]
        state = st.session_state.tutor_state
        state["problem"] = entry["problem"]
        state["hints_shown"] = entry["hints"].copy()
        state["shown_levels"] = set(h["level"] for h in entry["hints"])
        state["working_analysis"] = entry["working_analysis"]
        state["targeted_hint"] = entry["targeted_hint"]
        state["final_answer"] = entry["final_answer"]
        state["attempts_made"] = len([h for h in entry["hints"] if h["level"] == 3]) + (1 if entry["working_analysis"] else 0)
        # Note: solution is not restored (hidden), user would need to click Start Problem again


# --- Sidebar ---
with st.sidebar:
    st.header("⚙️ Settings")

    # Model selector
    model_option = st.selectbox(
        "Model",
        ["MODEL_MAIN (nemotron-3-super)", "MODEL_FAST (nemotron-3-super)"],
        index=0,
        help="MODEL_MAIN and MODEL_FAST both use nemotron-3-super-120b-a12b via NVIDIA NIM"
    )
    model_key = "MODEL_MAIN" if "MAIN" in model_option else "MODEL_FAST"
    model_name = os.getenv(model_key, "nvidia/nemotron-3-super-120b-a12b")

    # Debug toggle
    show_debug = st.checkbox("Show Debug Info", value=False)

    st.divider()

    # --- HISTORY PANEL ---
    st.header("📜 Session History")
    if st.button("Clear History", use_container_width=True):
        clear_history()
        st.rerun()

    if st.session_state.history:
        for idx, entry in enumerate(st.session_state.history):
            with st.expander(f"{entry['timestamp']} — {entry['problem'][:50]}{'...' if len(entry['problem']) > 50 else ''}", expanded=False):
                st.caption(f"Problem: {entry['problem']}")
                if entry["solution_answer"]:
                    st.caption(f"Answer: {entry['solution_answer']}")

                # Show hints given
                for h in entry["hints"]:
                    level_names = {1: "L1 Orient", 2: "L2 Strategy", 3: "L3 Walkthrough"}
                    guard_short = h["guard_status"]
                    if guard_short.startswith("regenerated"):
                        guard_short = f"regen {guard_short.split('_')[1]}×"
                    st.markdown(f"**{level_names.get(h['level'], f'L{h['level']}')}** ({guard_short})")
                    st.caption(h["hint"][:120] + ("..." if len(h["hint"]) > 120 else ""))

                # Show working analysis
                if entry["working_analysis"]:
                    wa = entry["working_analysis"]
                    if wa.has_error:
                        st.warning(f"⚠️ Step {wa.first_wrong_step_index + 1} flagged: {wa.error_type}")
                    else:
                        st.success("✅ No errors")

                # Show targeted hint
                if entry["targeted_hint"]:
                    th = entry["targeted_hint"]
                    st.info(f"Targeted hint: {th['hint'][:100]}...")

                # Show final answer
                if entry["final_answer"]:
                    correct = "✅" if entry["solution_answer"] and normalise_numeric_equal(entry["final_answer"], entry["solution_answer"]) else "❌"
                    st.markdown(f"**Your answer:** {entry['final_answer']} {correct}")

                if st.button("Load This Problem", key=f"load_{idx}", use_container_width=True):
                    load_history_problem(idx)
                    st.rerun()
    else:
        st.caption("No problems solved yet. Start a new problem!")

    st.divider()
    st.caption("Hint-Based Math Tutor — Problem 13")


# --- MAIN TUTOR TAB ---
def main():
    st.title("🧮 Hint-Based Math Tutor")
    st.caption("Progressive hints without revealing answers early")

    state = st.session_state.tutor_state

    # Problem input
    problem_text = st.text_area(
        "Math Word Problem",
        value=state["problem"],
        height=100,
        placeholder="Enter a math word problem...\n\nExample: Sarah has 15 apples. She gives 4 to her friend and buys 7 more. How many apples does she have now?"
    )

    col1, col2, col3 = st.columns([1, 1, 1])
    with col1:
        if st.button("Start Problem", type="primary", use_container_width=True):
            if problem_text.strip():
                with st.spinner("Starting problem..."):
                    result = start_problem(problem_text, model=model_name)

                    state["problem"] = problem_text
                    state["refusal"] = None
                    state["solution"] = None
                    state["hints_shown"] = []
                    state["shown_levels"] = set()
                    state["attempts_made"] = 0
                    state["working_analysis"] = None
                    state["targeted_hint"] = None

                    if result["status"] == "ok":
                        state["solution"] = result.get("solution")
                        st.success("Problem ready! Click Hint 1 to begin.")
                    else:
                        state["refusal"] = result["refusal_message"]
                        st.error(result["refusal_message"])
                    st.rerun()
            else:
                st.error("Please enter a problem")

    with col2:
        if st.button("Try Random Problem", use_container_width=True):
            prob = random.choice(EXTRA_PROBLEMS)
            state["problem"] = prob["text"]
            st.rerun()

    with col3:
        if st.button("New Problem", use_container_width=True):
            reset_tutor()
            st.rerun()

    # Show refusal if any
    if state["refusal"]:
        st.error(f"⛔ {state['refusal']}")
        st.stop()

    # Show solution in debug
    if show_debug and state["solution"]:
        with st.expander("🔍 Hidden Solution (Debug Only)"):
            sol = state["solution"]
            for step in sol.steps:
                st.write(f"- {step.description}: {step.expression} = {step.result}")
            st.write(f"**Final Answer:** {sol.final_answer}")

    # Hint buttons
    if state["solution"]:
        st.divider()
        st.subheader("Get Hints")

        hint_cols = st.columns(3)

        # Hint 1
        with hint_cols[0]:
            hint1_shown = any(h["level"] == 1 for h in state["hints_shown"])
            if st.button("Hint 1 (Orient)", disabled=hint1_shown, use_container_width=True):
                with st.spinner("Generating Hint 1..."):
                    prev_hints = [h["hint"] for h in state["hints_shown"]]
                    result = get_hint(state["problem"], state["solution"], 1, prev_hints, model=model_name)
                    state["hints_shown"].append({"level": 1, **result})
                    state["shown_levels"].add(1)
                    st.rerun()

        # Hint 2
        with hint_cols[1]:
            hint2_shown = any(h["level"] == 2 for h in state["hints_shown"])
            disabled = hint2_shown or not any(h["level"] == 1 for h in state["hints_shown"])
            if st.button("Hint 2 (Strategy)", disabled=disabled, use_container_width=True):
                with st.spinner("Generating Hint 2..."):
                    prev_hints = [h["hint"] for h in state["hints_shown"]]
                    result = get_hint(state["problem"], state["solution"], 2, prev_hints, model=model_name)
                    state["hints_shown"].append({"level": 2, **result})
                    state["shown_levels"].add(2)
                    st.rerun()

        # Hint 3
        with hint_cols[2]:
            hint3_shown = any(h["level"] == 3 for h in state["hints_shown"])
            can_unlock = can_unlock_level3(list(state["shown_levels"]), state["attempts_made"])
            disabled = hint3_shown or not can_unlock
            if st.button("Hint 3 (Walkthrough)", disabled=disabled, use_container_width=True):
                with st.spinner("Generating Walkthrough..."):
                    prev_hints = [h["hint"] for h in state["hints_shown"]]
                    result = get_hint(state["problem"], state["solution"], 3, prev_hints, model=model_name)
                    state["hints_shown"].append({"level": 3, **result})
                    state["shown_levels"].add(3)
                    st.rerun()

            if not can_unlock and not hint3_shown:
                st.caption("⚠️ Unlock after Level 1 & 2 or an attempt")

        # Display hints
        if state["hints_shown"]:
            st.divider()
            st.subheader("Hints Given")
            for h in state["hints_shown"]:
                format_hint_card(h["level"], h["hint"], h.get("follow_up"), h["guard_status"], h["attempts"])

    # Working check
    if state["solution"]:
        st.divider()
        st.subheader("📝 Check Your Working")

        working_text = st.text_area(
            "Show your working (one step per line)",
            height=100,
            placeholder="Example:\n15 - 4 = 11\n11 + 7 = 18"
        )

        col1, col2 = st.columns([1, 2])
        with col1:
            if st.button("Check My Working", type="secondary", use_container_width=True):
                if working_text.strip():
                    state["attempts_made"] += 1
                    with st.spinner("Analyzing working..."):
                        analysis = analyze_working(state["problem"], state["solution"], working_text, model=model_name)
                        state["working_analysis"] = analysis

                        # Determine current level for targeted hint
                        current_level = 1
                        if any(h["level"] >= 2 for h in state["hints_shown"]):
                            current_level = 2

                        targeted = generate_targeted_hint(
                            state["problem"], state["solution"], analysis, current_level, model=model_name
                        )
                        state["targeted_hint"] = targeted
                    st.rerun()
                else:
                    st.error("Please enter your working")

        with col2:
            if state["working_analysis"]:
                wa = state["working_analysis"]
                if wa.has_error:
                    st.warning(f"⚠️ Step {wa.first_wrong_step_index + 1} flagged: **{wa.error_type}**")
                else:
                    st.success("✅ No errors detected")

        # Show targeted hint
        if state["targeted_hint"]:
            th = state["targeted_hint"]
            format_hint_card(
                1 if "Orient" in str(th.get("follow_up", "")) else 2,
                th["hint"],
                th.get("follow_up"),
                th["guard_status"],
                th["attempts"]
            )

    # Final answer
    if state["solution"]:
        st.divider()
        st.subheader("🎯 Your Final Answer")
        final_answer = st.text_input("Enter your final answer", value=state["final_answer"])
        state["final_answer"] = final_answer

        if st.button("Check Answer", use_container_width=True):
            if final_answer.strip():
                correct = normalise_numeric_equal(final_answer, state["solution"].final_answer)
                if correct:
                    st.success("✅ Correct!")
                else:
                    st.error(f"❌ Incorrect. The answer is: {state['solution'].final_answer}")
            else:
                st.error("Please enter an answer")

    # Debug log
    if show_debug:
        st.divider()
        st.subheader("🐛 Debug Log")
        for entry in get_debug_log():
            st.json(entry)


if __name__ == "__main__":
    main()