app.py

import os
import random
import datetime
from functools import wraps

import requests
from dotenv import load_dotenv

from flask import Flask, request, jsonify, session, send_from_directory, redirect
from flask_cors import CORS

import firebase_admin
from firebase_admin import credentials, auth, firestore

# OpenAI is optional (only needed for /api/petchat)
try:
    from openai import OpenAI
except Exception:
    OpenAI = None

# ==============================
# Config / init
# ==============================
load_dotenv()

BASE_DIR = os.path.dirname(os.path.abspath(__file__))
TEMPLATE_DIR = os.path.join(BASE_DIR, "template")

# Serve HTML from /template and also serve static assets from /template
# so links like /styles/style.css and /scripts/script.js work.
app = Flask(
    __name__,
    template_folder="template",
    static_folder="template",
    static_url_path="",
)

# Cookies (helps with session)
app.config.update(
    SESSION_COOKIE_HTTPONLY=True,
    SESSION_COOKIE_SAMESITE="Lax",
)

CORS(app, supports_credentials=True)

# REQUIRED ENV VARS:
# - FLASK_SECRET_KEY
# - FIREBASE_API_KEY
# - GOOGLE_APPLICATION_CREDENTIALS (path to serviceAccountKey.json)
app.secret_key = os.getenv("FLASK_SECRET_KEY", "dev_change_me")

FIREBASE_API_KEY = os.getenv("FIREBASE_API_KEY")
SERVICE_ACCOUNT_JSON = os.getenv("GOOGLE_APPLICATION_CREDENTIALS")

# Friendly fallback: if GOOGLE_APPLICATION_CREDENTIALS is not set,
# try serviceAccountKey.json in the project folder.
if not SERVICE_ACCOUNT_JSON:
    local_key = os.path.join(BASE_DIR, "serviceAccountKey.json")
    if os.path.exists(local_key):
        SERVICE_ACCOUNT_JSON = local_key

if not FIREBASE_API_KEY:
    raise RuntimeError("Missing FIREBASE_API_KEY in .env")
if not SERVICE_ACCOUNT_JSON:
    raise RuntimeError(
        "Missing GOOGLE_APPLICATION_CREDENTIALS in .env (or serviceAccountKey.json not found next to app.py)"
    )

if not firebase_admin._apps:
    firebase_admin.initialize_app(credentials.Certificate(SERVICE_ACCOUNT_JSON))

db = firestore.client()

# OpenAI client (optional)
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
openai_client = OpenAI(api_key=OPENAI_API_KEY) if (OPENAI_API_KEY and OpenAI) else None


# ==============================
# Helpers
# ==============================

def login_required(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        if not session.get("uid"):
            return jsonify({"error": "Not logged in"}), 401
        return fn(*args, **kwargs)

    return wrapper


def user_ref(uid: str):
    return db.collection("users").document(uid)


def ensure_user_doc(uid: str, email: str, username: str = ""):
    ref = user_ref(uid)
    snap = ref.get()
    if snap.exists:
        return ref

    ref.set(
        {
            "email": email,
            "username": username,
            "coins": 0,
            "pet": {"hunger": 50, "thirst": 50, "health": 50, "happiness": 50},
            "flashcard_counter": 0,
            "todo_counter": 0,
            "chat": {
                # No logs stored. Just a persona/settings blob.
                "persona": "You are a friendly virtual pet. Keep replies short, playful, and encouraging.",
            },
        }
    )
    return ref


def parse_int(v, default=None):
    try:
        return int(v)
    except Exception:
        return default


def next_counter(ref, field_name: str) -> int:
    tx = db.transaction()

    @firestore.transactional
    def _inc(transaction):
        snap = ref.get(transaction=transaction)
        current = int(snap.get(field_name) or 0)
        new_val = current + 1
        transaction.update(ref, {field_name: new_val})
        return new_val

    return _inc(tx)


def firebase_password_login(email: str, password: str):
    """Firebase Admin SDK cannot verify email/password.
    Use Firebase Auth REST API signInWithPassword.
    """
    url = (
        "https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword"
        f"?key={FIREBASE_API_KEY}"
    )
    payload = {"email": email, "password": password, "returnSecureToken": True}
    r = requests.post(url, json=payload, timeout=15)
    if r.status_code != 200:
        try:
            code = r.json().get("error", {}).get("message", "LOGIN_FAILED")
        except Exception:
            code = "LOGIN_FAILED"
        return None, code
    return r.json(), None


# ==============================
# Pages
# ==============================

@app.get("/")
def root():
    return redirect("/login.html")

@app.get("/login.html")
def login_page():
    return send_from_directory("template", "login.html")

@app.get("/signup.html")
def signup_page():
    return send_from_directory("template", "signup.html")

@app.get("/dashboard.html")
def dashboard_page():
    return send_from_directory("template", "dashboard.html")


# ==============================
# Auth APIs
# ==============================

@app.post("/api/signup")
def api_signup():
    body = request.get_json(silent=True) or {}
    username = str(body.get("username", "")).strip()
    email = str(body.get("email", "")).strip()
    password = str(body.get("password", "")).strip()

    if not username or not email or not password:
        return jsonify({"error": "username, email, password required"}), 400

    try:
        u = auth.create_user(email=email, password=password, display_name=username)
        ensure_user_doc(u.uid, email=email, username=username)

        # auto login
        data, err = firebase_password_login(email, password)
        if err:
            return jsonify({"error": "Signup succeeded, but login failed", "code": err}), 401

        session["uid"] = data["localId"]
        session["email"] = email
        return jsonify({"ok": True})

    except auth.EmailAlreadyExistsError:
        return jsonify({"error": "Email already in use"}), 400
    except Exception as e:
        return jsonify({"error": "Signup failed", "detail": str(e)}), 400


@app.post("/api/login")
def api_login():
    body = request.get_json(silent=True) or {}
    email = str(body.get("email", "")).strip()
    password = str(body.get("password", "")).strip()

    if not email or not password:
        return jsonify({"error": "email and password required"}), 400

    data, err = firebase_password_login(email, password)
    if err:
        return jsonify({"error": err, "code": err}), 401

    uid = data["localId"]
    ensure_user_doc(uid, email=email)

    session["uid"] = uid
    session["email"] = email
    return jsonify({"ok": True})


@app.post("/api/logout")
def api_logout():
    session.clear()
    return jsonify({"ok": True})


# ==============================
# Profile update
# ==============================

@app.put("/api/profile")
@login_required
def api_profile_update():
    uid = session["uid"]
    body = request.get_json(silent=True) or {}

    username = str(body.get("username", "")).strip()
    email = str(body.get("email", "")).strip()
    new_password = body.get("password", None)

    if not username or not email:
        return jsonify({"error": "Username and email are required."}), 400

    # Update Firebase Auth (Admin SDK)
    try:
        args = {"display_name": username, "email": email}
        if new_password is not None and str(new_password).strip() != "":
            args["password"] = str(new_password)
        auth.update_user(uid, **args)
    except Exception as e:
        msg = str(e)
        upper = msg.upper()
        code = ""
        if "WEAK_PASSWORD" in upper or "AT LEAST" in upper or "6" in upper:
            code = "WEAK_PASSWORD"
        elif "INVALID_EMAIL" in upper:
            code = "INVALID_EMAIL"
        elif "EMAIL_ALREADY_EXISTS" in upper or "EMAIL_EXISTS" in upper:
            code = "EMAIL_EXISTS"
        return jsonify({"error": "Profile update failed", "code": code, "detail": msg}), 400

    # Update Firestore user doc
    updates = {"username": username, "email": email}
    if new_password is not None and str(new_password).strip() != "":
        # We never store actual password, only length so you can render *****
        updates["password_length"] = len(str(new_password))

    user_ref(uid).set(updates, merge=True)
    session["email"] = email
    return jsonify({"ok": True})


# ==============================
# User Data
# ==============================

@app.get("/api/me")
@login_required
def api_me():
    uid = session["uid"]
    d = user_ref(uid).get().to_dict() or {}
    d["uid"] = uid
    return jsonify(d)


@app.put("/api/me")
@login_required
def api_update_me():
    uid = session["uid"]
    ref = user_ref(uid)
    body = request.get_json(silent=True) or {}

    updates = {}
    if "username" in body:
        updates["username"] = str(body["username"]).strip()

    if "coins" in body:
        coins = parse_int(body["coins"], None)
        if coins is None or coins < 0:
            return jsonify({"error": "coins must be non-negative int"}), 400
        updates["coins"] = coins

    if not updates:
        return jsonify({"error": "No valid fields"}), 400

    ref.update(updates)
    return jsonify({"ok": True})


# ==============================
# Pet Data
# ==============================

@app.get("/api/pet")
@login_required
def api_get_pet():
    uid = session["uid"]
    d = user_ref(uid).get().to_dict() or {}
    return jsonify(d.get("pet", {}))


@app.put("/api/pet")
@login_required
def api_update_pet():
    uid = session["uid"]
    ref = user_ref(uid)
    body = request.get_json(silent=True) or {}

    allowed = ["hunger", "thirst", "health", "happiness"]
    pet_updates = {}
    for k in allowed:
        if k in body:
            v = parse_int(body[k], None)
            if v is None or v < 0:
                return jsonify({"error": f"{k} must be non-negative int"}), 400
            pet_updates[f"pet.{k}"] = v

    if not pet_updates:
        return jsonify({"error": "No valid pet fields"}), 400

    ref.update(pet_updates)
    return jsonify({"ok": True})


# ==============================
# Flashcards
# ==============================

@app.get("/api/flashcards")
@login_required
def api_list_flashcards():
    uid = session["uid"]
    out = []
    for doc in user_ref(uid).collection("flashcards").stream():
        d = doc.to_dict()
        d["id"] = doc.id
        out.append(d)
    out.sort(key=lambda x: int(x.get("number", 0)))
    return jsonify(out)


@app.post("/api/flashcards")
@login_required
def api_create_flashcard():
    uid = session["uid"]
    uref = user_ref(uid)

    body = request.get_json(silent=True) or {}
    front = str(body.get("front", "")).strip()
    back = str(body.get("back", "")).strip()
    if not front or not back:
        return jsonify({"error": "front and back required"}), 400

    number = next_counter(uref, "flashcard_counter")
    doc_ref = uref.collection("flashcards").document()
    doc_ref.set({"number": number, "front": front, "back": back})
    return jsonify({"ok": True, "id": doc_ref.id, "number": number}), 201


# ==============================
# Todos
# ==============================

@app.get("/api/todos")
@login_required
def api_list_todos():
    uid = session["uid"]
    out = []
    for doc in user_ref(uid).collection("todos").stream():
        d = doc.to_dict()
        d["id"] = doc.id
        out.append(d)
    out.sort(key=lambda x: int(x.get("number", 0)))
    return jsonify(out)


@app.post("/api/todos")
@login_required
def api_create_todo():
    uid = session["uid"]
    uref = user_ref(uid)

    body = request.get_json(silent=True) or {}
    todo_name = str(body.get("todo_name", "")).strip()
    coin_worth = parse_int(body.get("coin_worth", 0), None)

    if not todo_name:
        return jsonify({"error": "todo_name required"}), 400
    if coin_worth is None or coin_worth < 0:
        return jsonify({"error": "coin_worth must be non-negative int"}), 400

    number = next_counter(uref, "todo_counter")
    doc_ref = uref.collection("todos").document()
    doc_ref.set({"number": number, "todo_name": todo_name, "coin_worth": coin_worth, "done": False})
    return jsonify({"ok": True, "id": doc_ref.id, "number": number}), 201


# ==============================
# AI Daily Quest (3 per day)
# ==============================

QUEST_BANK = [
    "Do a 10-minute review of today’s notes and write 3 key takeaways.",
    "Solve 3 practice problems from your current topic and check one mistake.",
    "Make 5 flashcards for a chapter/lecture and test yourself once.",
    "Write a 4-sentence summary of what you learned today in your own words.",
    "Spend 15 minutes cleaning up your to-do list: prioritize top 3 tasks.",
    "Write a small function (10–20 lines) to practice a concept you’re learning (loops, lists, recursion).",
    "Refactor one small piece of code: rename variables + add 2 helpful comments.",
    "Do 1 LeetCode easy (or similar) and write down the core idea in 2 sentences.",
    "Explain a CS concept to your pet in 3 sentences (e.g., stacks vs queues).",
    "Work 2 math/physics drills and note 1 pattern you noticed.",
    "Draw a diagram for a physics problem and label forces/known values.",
    "Pick 1 formula you keep forgetting and create a memory cue for it.",
]


def _utc_date_key():
    return datetime.datetime.utcnow().strftime("%Y-%m-%d")


def _pick_three_quests(seed_key: str):
    rng = random.Random(seed_key)
    bank = QUEST_BANK[:]
    rng.shuffle(bank)
    return bank[:3]


def _ensure_daily_quests(uid: str):
    date_key = _utc_date_key()
    ref = db.collection("users").document(uid).collection("daily_quests").document(date_key)
    doc = ref.get()
    if doc.exists:
        return doc.to_dict(), date_key

    quests = _pick_three_quests(seed_key=f"{uid}:{date_key}")
    payload = {
        "date": date_key,
        "created_at": firestore.SERVER_TIMESTAMP,
        "quests": [
            {"qid": "q1", "text": quests[0], "done": False, "reward": 10},
            {"qid": "q2", "text": quests[1], "done": False, "reward": 10},
            {"qid": "q3", "text": quests[2], "done": False, "reward": 10},
        ],
    }
    ref.set(payload)
    return payload, date_key


@app.get("/api/daily_quests")
@login_required
def api_daily_quests():
    uid = session["uid"]
    data, date_key = _ensure_daily_quests(uid)
    return jsonify({"date": date_key, "quests": data.get("quests", [])})


@app.post("/api/daily_quests/complete")
@login_required
def api_daily_quests_complete():
    uid = session["uid"]
    body = request.get_json(silent=True) or {}
    qid = body.get("qid")
    if not qid:
        return jsonify({"error": "Missing qid"}), 400

    data, date_key = _ensure_daily_quests(uid)
    ref = db.collection("users").document(uid).collection("daily_quests").document(date_key)

    quests = data.get("quests", [])
    idx = next((i for i, q in enumerate(quests) if q.get("qid") == qid), None)
    if idx is None:
        return jsonify({"error": "Quest not found"}), 404

    if quests[idx].get("done") is True:
        user_doc = user_ref(uid).get().to_dict() or {}
        return jsonify({"ok": True, "already": True, "coins": user_doc.get("coins", 0)})

    reward = int(quests[idx].get("reward", 10))

    @firestore.transactional
    def _tx_complete(tx):
        qsnap = ref.get(transaction=tx)
        qdata = qsnap.to_dict() or {}
        qlist = qdata.get("quests", [])
        for q in qlist:
            if q.get("qid") == qid:
                if q.get("done") is True:
                    return False
                q["done"] = True
        tx.set(ref, {"quests": qlist}, merge=True)

        uref = user_ref(uid)
        usnap = uref.get(transaction=tx)
        udata = usnap.to_dict() or {}
        current = int(udata.get("coins", 0))
        tx.set(uref, {"coins": current + reward}, merge=True)
        return True

    tx = db.transaction()
    changed = _tx_complete(tx)

    user_doc = user_ref(uid).get().to_dict() or {}
    return jsonify({"ok": True, "updated": bool(changed), "coins": user_doc.get("coins", 0), "reward": reward})


# ==============================
# AI Pet Chat (no persistence)
# ==============================

@app.post("/api/petchat")
@login_required
def api_petchat():
    body = request.get_json(silent=True) or {}
    user_msg = (body.get("message") or "").strip()

    if not user_msg:
        return jsonify({"error": "Message is empty"}), 400

    if openai_client is None:
        return jsonify({"error": "OPENAI_API_KEY missing (or openai not installed)"}), 500

    system_prompt = (
        "You are 'Kat', a cute virtual pet tutor.\n"
        "Personality: friendly, upbeat, supportive; short + clear by default.\n"
        "Educational rules: If user asks school questions, teach step-by-step, explain reasoning, and check understanding. "
        "Ask 1 clarifying question if needed. Never give only a final answer without explanation. Encourage good study habits."
    )

    try:
        resp = openai_client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_msg},
            ],
            temperature=0.7,
            max_tokens=350,
        )
        reply = (resp.choices[0].message.content or "").strip()
        return jsonify({"reply": reply})
    except Exception as e:
        return jsonify({"error": "Pet chat failed", "detail": str(e)}), 500


# ==============================
# Run
# ==============================

if __name__ == "__main__":
    # IMPORTANT: run on ONE port only.
    # Use PORT if set, otherwise default to 5001 (matches your JS logs).
    port = int(os.getenv("PORT", "5001"))
    app.run(host="127.0.0.1", port=port, debug=True)