app.py

from flask import Flask, render_template, request, session, redirect, url_for, flash, get_flashed_messages, jsonify
from werkzeug.security import generate_password_hash, check_password_hash
from datetime import datetime
import io
from contextlib import redirect_stdout
import json
import os
from unittest.mock import patch
from api import create_api_routes
from ai_hint_generator import AIHintGenerator
from progress_tracker import ProgressTracker


def safe_exec_with_input(user_code, test_input):
    buf = io.StringIO()
    exec_globals = {}
    try:
        with patch("builtins.input", return_value=test_input), redirect_stdout(buf):
            exec(user_code, exec_globals)
        output = buf.getvalue().strip()
        return output, None
    except Exception as e:
        return None, str(e)




app = Flask(__name__)
app.secret_key = "game101"


# Initialize AI hint generator and progress tracker
hint_generator = AIHintGenerator()
progress_tracker = ProgressTracker()


# Create API routes
create_api_routes(app)

# Load levels
with open("levels.json") as f:
    levels = json.load(f)


# Load users
USERS_FILE = "users.json"

def load_users():
    if not os.path.exists(USERS_FILE):
        return {}
    with open(USERS_FILE, "r", encoding="utf-8") as f:
        return json.load(f)

def save_users(users):
    with open(USERS_FILE, "w", encoding="utf-8") as f:
        json.dump(users, f, indent=2)




@app.route("/")
def home():
    return render_template("get_started.html")





@app.route("/reset")
def reset():
    session.clear()
    return redirect(url_for("play"))


@app.route("/reset_progress", methods=["POST"])
def reset_progress():
    if "username" in session:
        username = session["username"]
        users = load_users()

        # Reset progress in users.json
        if username in users and "progress" in users[username]:
            users[username]["progress"]["score"] = 0
            users[username]["progress"]["level"] = 1
            save_users(users)
            
        progress_tracker.reset_user(username)    

        # Reset session data
        session["score"] = 0
        session["level"] = 1
        session["wrong_attempts"] = 0
        session["show_hint"] = False
        session["user_code"] = ""
        session["start_time"] = datetime.now().isoformat()

        flash("🔄 Progress reset successfully!", "success")
    else:
        flash("⚠️ You need to be logged in to reset progress.", "danger")

    return redirect(url_for("settings"))



@app.route("/play/<int:level_num>", methods=["GET", "POST"])
def play_level(level_num):
    if "username" not in session:
        return redirect(url_for("login"))
        
    username = session["username"]
    
    # Ensure progress tracking is initialized for this user
    progress_tracker.ensure_user_exists(username)
    
    # Start progress tracking for this level
    progress_tracker.start_level_session(username, level_num)
    
    with open("levels.json", "r") as f:
        levels = json.load(f)

    unlocked = session.get("level", 1)
    if level_num > unlocked:
        return redirect(url_for("level_select"))

    level_data = levels.get(str(level_num), {})
    default_code = "print('Hello')" if level_num == 1 else ""
    user_code = session.get("user_code", default_code)
    show_hint = session.pop("show_hint", False)

    if request.method == "POST":
        if "reset_code" in request.form:
            session["user_code"] = ""
        elif "show_hint" in request.form:
            print(f"💡 Hint requested for user {username} on level {level_num}")
            # Generate AI hint
            level_data['level_num'] = level_num
            user_code = session.get("user_code", "")
            wrong_attempts = session.get("wrong_attempts", 0)
            
            # Record hint usage in progress tracker
            progress_tracker.record_hint_usage(username, level_num)
            
            try:
                ai_hints = hint_generator.generate_hints(level_data, user_code, wrong_attempts)
                session["ai_hints"] = ai_hints
                session["show_hint"] = True
            except Exception as e:
                session["ai_hints"] = ["Try thinking about the basic concepts needed for this challenge."]
                session["show_hint"] = True
        else:
            user_code = request.form.get("code", "")
            session["user_code"] = user_code
            output, error = safe_exec_with_input(user_code, level_data.get("test_input", ""))

            if error:
                print(f"❌ Wrong attempt (error) for user {username} on level {level_num}")
                flash(f"❌ Error in your code: {error}", "danger")
                session["wrong_attempts"] = session.get("wrong_attempts", 0) + 1
                # Record wrong attempt in progress tracker
                progress_tracker.record_wrong_attempt(username, level_num)
                return redirect(url_for("play_level", level_num=level_num))

            if output.strip() == level_data.get("expected_output", "").strip():
                # Complete level in progress tracker and get IQ score
                iq_score = progress_tracker.complete_level(username, level_num)
                
                flash(f"✅ Correct! Good job! IQ Score: {iq_score}", "success")
                if level_num == session.get("level", 1):
                    session["level"] = level_num + 1
                session.pop("user_code", None)
                return redirect(url_for("progress_dashboard"))
            else:
                print(f"❌ Wrong attempt (incorrect output) for user {username} on level {level_num}")
                flash("❌ Incorrect output. Try again.", "danger")
                session["wrong_attempts"] = session.get("wrong_attempts", 0) + 1
                # Record wrong attempt in progress tracker
                progress_tracker.record_wrong_attempt(username, level_num)
                return redirect(url_for("play_level", level_num=level_num))

    # Use AI hints if available, otherwise use default hint
    ai_hints = session.pop("ai_hints", None)
    if ai_hints:
        hint = ai_hints[0] if ai_hints else None  # For backward compatibility, show first hint
    else:
        hint = level_data.get("hint", f"Think about Python basics for Level {level_num}.") if show_hint else None

    return render_template(
        "play.html",
        level=level_num,
        title=level_data.get("title", f"Challenge {level_num}"),
        instruction=level_data.get("instruction", f"Write a Python statement to solve Level {level_num}."),
        score=100,
        user_code=user_code,
        show_hint=show_hint,
        hint=hint
    )




# HINT HERE

@app.route("/play", methods=["GET", "POST"])
def play():
    if "username" not in session:
        return redirect(url_for("login"))

    username = session["username"]
    
    # Ensure progress tracking is initialized for this user
    progress_tracker.ensure_user_exists(username)

    session.setdefault("level", 1)
    session.setdefault("score", 0)
    session.setdefault("wrong_attempts", 0)
    session.setdefault("show_hint", False)
    session.setdefault("user_code", "")
    session.setdefault("start_time", datetime.now().isoformat())

    level = session["level"]
    score = session["score"]
    wrong_attempts = session["wrong_attempts"]
    show_hint = session["show_hint"]
    user_code = session.get("user_code", "")

    # Start progress tracking for this level
    progress_tracker.start_level_session(username, level)

    with open("levels.json", "r") as f:
        levels = json.load(f)

    level_data = levels.get(str(level))
    if not level_data:
        return render_template("win.html", score=score)

    title = level_data["title"]
    instruction = level_data["instruction"]
    function_name = level_data["function_name"]
    test_input = level_data["test_input"]
    expected_output = level_data["expected_output"]
    hint_text = level_data["hint"]
    uses_function = level_data.get("uses_function", True)

    start_time = datetime.fromisoformat(session["start_time"])
    elapsed_total = datetime.now() - start_time
    elapsed_minutes = elapsed_total.seconds // 60
    elapsed_seconds = elapsed_total.seconds % 60

    if request.method == "POST":
        current_level = session.get("level", 1)
        if request.form.get("reset_code") == "1":
            session["user_code"] = ""
        elif request.form.get("show_hint") == "1":
            print(f"💡 Hint requested for user {username} on level {current_level}")
            # Generate AI hint
            level_data = levels.get(str(current_level), {})
            level_data['level_num'] = current_level
            user_code = session.get("user_code", "")
            wrong_attempts = session.get("wrong_attempts", 0)
            # Record hint usage in progress tracker
            progress_tracker.record_hint_usage(username, current_level)
            
            try:
                ai_hints = hint_generator.generate_hints(level_data, user_code, wrong_attempts)
                session["ai_hints"] = ai_hints
                session["show_hint"] = True
            except Exception as e:
                session["ai_hints"] = ["Try thinking about the basic concepts needed for this challenge."]
                session["show_hint"] = True
        else:
            user_code = request.form.get("code", "")
            session["user_code"] = user_code

            try:
                exec_globals = {}
                try:
                    parsed_input = eval(test_input)
                except:
                    parsed_input = test_input

                if uses_function:
                    exec(user_code, exec_globals)
                    if function_name not in exec_globals:
                        raise Exception(f"Function '{function_name}' is not defined!")
                    result = exec_globals[function_name](parsed_input)
                    output = str(result).strip()
                else:
                    output, error = safe_exec_with_input(user_code, parsed_input)
                    if error:
                        raise Exception(error)

                if output == str(expected_output).strip():
                    # Complete level in progress tracker and get IQ score
                    iq_score = progress_tracker.complete_level(username, level)
                    
                    flash(f"✅ Correct! Good job! IQ Score: {iq_score}", "success")
                    session["score"] += 1
                    session["level"] += 1
                    session["wrong_attempts"] = 0
                    session["show_hint"] = False
                    session["user_code"] = ""

                    users = load_users()
                    username = session["username"]
                    if username in users:
                        users[username].setdefault("progress", {})
                        users[username]["progress"]["score"] = session["score"]
                        users[username]["progress"]["level"] = session["level"]
                        save_users(users)

                    return redirect(url_for("play"))
                else:
                    print(f"❌ Wrong attempt (incorrect output) for user {username} on level {current_level}")
                    flash("❌ Incorrect. Try again.", "danger")
                    session["wrong_attempts"] += 1
                    # Record wrong attempt in progress tracker
                    progress_tracker.record_wrong_attempt(username, current_level)

            except Exception as e:
                print(f"❌ Wrong attempt (error) for user {username} on level {current_level}")
                flash(f"❌ Error in your code: {e}", "danger")
                session["wrong_attempts"] += 1
                # Record wrong attempt in progress tracker
                progress_tracker.record_wrong_attempt(username, current_level)
    # Use AI hints if available, otherwise use default hint
    ai_hints = session.pop("ai_hints", None)
    if ai_hints:
        hint = ai_hints[0] if ai_hints else None  # For backward compatibility, show first hint
    else:
        hint = hint_text if show_hint else None

    return render_template(
        "play.html",
        level=level,
        score=score,
        correct=False,
        user_code=session.get("user_code", ""),
        hint=hint,
        title=title,
        instruction=instruction,
        elapsed_minutes=elapsed_minutes,
        elapsed_seconds=elapsed_seconds,
        feedback=None
    )


@app.route("/update_theme", methods=["POST"])
def update_theme():
    if "username" not in session:
        return redirect(url_for("login"))

    selected_theme = request.form.get("theme", "default")

    if session.get("theme") != selected_theme:
        session["theme"] = selected_theme
        flash("🎨 Theme updated successfully!", "success")

        users = load_users()
        username = session["username"]
        if username in users:
            users[username].setdefault("preferences", {})["theme"] = selected_theme
            save_users(users)

    return redirect(url_for("settings"))





@app.route("/instructions")
def instructions():
    return render_template("instructions.html")


@app.route("/library")
def library():
    return render_template("library.html")




@app.route("/register", methods=["GET", "POST"])
def register():
    if request.method == "POST":
        username = request.form["username"]
        email = request.form["email"]
        password = request.form["password"]
        confirm = request.form["confirm"]

        users = load_users()

        if username in users:
            flash("❌ Username already exists!", "danger")
        elif password != confirm:
            flash("❌ Passwords do not match!", "danger")
        elif not username or not password or not email:
            flash("❌ All fields are required!", "danger")
        else:
            users[username] = {
                "email": email,
                "password": generate_password_hash(password),
                "progress": {
                    "level": 1,
                    "score": 0
                }
            }
            save_users(users)
            flash("✅ The signup was successful! Please log in.", "success")
            return redirect(url_for("login"))

    return render_template("register.html")




@app.route("/login", methods=["GET", "POST"])
def login():
    if request.method == "POST":
        username = request.form["username"]
        password = request.form["password"]

        users = load_users()
        user = users.get(username)

        if user and check_password_hash(user["password"], password):
            session["username"] = username
            session["level"] = user["progress"]["level"]
            session["score"] = user["progress"]["score"]
            session["wrong_attempts"] = 0
            session["show_hint"] = False
            session["user_code"] = ""
            
            # Ensure progress tracking is initialized for this user
            progress_tracker.ensure_user_exists(username)
            
            flash("✅ Welcome back, " + username + "!", "success")
            return redirect(url_for("index"))
        else:
            flash("❌ Invalid username or password", "danger")

    return render_template("login.html")  





@app.route("/logout")
def logout():
    session.clear()
    flash("✅ Logged out successfully.", "info")
    return redirect(url_for("login"))

@app.route("/index")
def index():
    if "username" not in session:
        return redirect(url_for("login"))
    return render_template("index.html")




@app.route("/settings")
def settings():
    return render_template("settings.html")


@app.route("/tutorials")
def tutorials():
    return render_template("tutorials.html")



@app.route("/levels")
def level_select():
    unlocked_level = session.get("level", 1)
    return render_template("levels.html", unlocked_level=unlocked_level, levels=levels)





@app.route("/leaderboard")
def leaderboard():
    users = load_users()
    leaderboard_data = []

    for username, data in users.items():
        progress = data.get("progress", {})
        score = progress.get("score", 0)
        level = progress.get("level", 1)
        leaderboard_data.append({
            "username": username,
            "score": score,
            "level": level
        })

    sorted_board = sorted(leaderboard_data, key=lambda x: x["score"], reverse=True)
    return render_template("leaderboard.html", top_players=sorted_board)



@app.route("/progress")
def progress_dashboard():
    if "username" not in session:
        return redirect(url_for("login"))
    
    username = session["username"]
    # Ensure progress tracking is initialized for this user
    progress_tracker.ensure_user_exists(username)
    
    print(f"Progress dashboard accessed by user: {username}")
    return render_template("progress_dashboard.html")

if __name__ == "__main__":
    app.run(debug=True)