# app.py 🎭
# One file, two personalities:
# - RUN_MODE=api   -> FastAPI JSON multiplayer relay
# - RUN_MODE=admin -> Streamlit admin console
#
# Shared state uses SQLite so both processes agree on reality.
# (In-memory is where bugs go to reproduce. 🐛💞)

import os, time, json, secrets, string, sqlite3
from typing import Any, Dict, Optional, List

DB_PATH = os.getenv("GAME_DB_PATH", "/data/game.sqlite")  # HF persistent storage uses /data 💾
CORS_ORIGINS = os.getenv("CORS_ORIGINS", "https://allaiinc.org").split(",")

def now_i() -> int:
    return int(time.time())

def rid(n=6) -> str:
    alphabet = string.ascii_uppercase + string.digits
    return "".join(secrets.choice(alphabet) for _ in range(n))

def tok() -> str:
    return secrets.token_urlsafe(24)

def db() -> sqlite3.Connection:
    # check_same_thread=False because Streamlit/FastAPI like to multitask 🤹
    conn = sqlite3.connect(DB_PATH, check_same_thread=False)
    conn.row_factory = sqlite3.Row
    return conn

def init_db():
    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
    con = db()
    cur = con.cursor()
    cur.executescript("""
    CREATE TABLE IF NOT EXISTS rooms(
      room TEXT PRIMARY KEY,
      created INTEGER NOT NULL,
      seq INTEGER NOT NULL,
      public_json TEXT NOT NULL
    );
    CREATE TABLE IF NOT EXISTS players(
      token TEXT PRIMARY KEY,
      room TEXT NOT NULL,
      seat INTEGER NOT NULL,
      name TEXT NOT NULL,
      last_seen INTEGER NOT NULL
    );
    CREATE TABLE IF NOT EXISTS private_state(
      room TEXT NOT NULL,
      seat INTEGER NOT NULL,
      private_json TEXT NOT NULL,
      PRIMARY KEY(room, seat)
    );
    CREATE TABLE IF NOT EXISTS events(
      room TEXT NOT NULL,
      seq INTEGER NOT NULL,
      t INTEGER NOT NULL,
      kind TEXT NOT NULL,
      data_json TEXT NOT NULL,
      PRIMARY KEY(room, seq)
    );
    """)
    con.commit()
    con.close()

def room_get(con, room: str):
    r = con.execute("SELECT * FROM rooms WHERE room=?", (room,)).fetchone()
    return r

def event_append(con, room: str, kind: str, data: Dict[str, Any]) -> int:
    r = room_get(con, room)
    if not r:
      raise ValueError("room not found")
    seq = int(r["seq"]) + 1
    con.execute("UPDATE rooms SET seq=? WHERE room=?", (seq, room))
    con.execute(
        "INSERT INTO events(room, seq, t, kind, data_json) VALUES(?,?,?,?,?)",
        (room, seq, now_i(), kind, json.dumps(data, ensure_ascii=False))
    )
    return seq

def players_roster(con, room: str) -> List[Dict[str, Any]]:
    rows = con.execute("SELECT seat, name, last_seen FROM players WHERE room=? ORDER BY seat", (room,)).fetchall()
    return [dict(r) for r in rows]

def player_by_token(con, token: str):
    return con.execute("SELECT * FROM players WHERE token=?", (token,)).fetchone()

def public_get(con, room: str) -> Dict[str, Any]:
    r = room_get(con, room)
    if not r:
        raise KeyError("room")
    return json.loads(r["public_json"])

def public_set(con, room: str, obj: Dict[str, Any]):
    con.execute("UPDATE rooms SET public_json=? WHERE room=?", (json.dumps(obj, ensure_ascii=False), room))

def private_get(con, room: str, seat: int) -> Dict[str, Any]:
    r = con.execute("SELECT private_json FROM private_state WHERE room=? AND seat=?", (room, seat)).fetchone()
    return json.loads(r["private_json"]) if r else {}

def private_set(con, room: str, seat: int, obj: Dict[str, Any]):
    con.execute(
        "INSERT INTO private_state(room, seat, private_json) VALUES(?,?,?) "
        "ON CONFLICT(room, seat) DO UPDATE SET private_json=excluded.private_json",
        (room, seat, json.dumps(obj, ensure_ascii=False))
    )

def cleanup_inactive(con, room: str, ttl: int = 180):
    # “If you haven’t pinged me in 3 minutes, I assume you went to get snacks.” 🍪
    cutoff = now_i() - ttl
    gone = con.execute("SELECT seat, name FROM players WHERE room=? AND last_seen < ?", (room, cutoff)).fetchall()
    if gone:
        con.execute("DELETE FROM players WHERE room=? AND last_seen < ?", (room, cutoff))
        for g in gone:
            event_append(con, room, "leave", {"seat": int(g["seat"]), "name": g["name"], "why": "timeout"})

# -----------------------------
# FastAPI mode 🧠⚡
# -----------------------------
if os.getenv("RUN_MODE", "api") == "api":
    from fastapi import FastAPI, HTTPException
    from fastapi.middleware.cors import CORSMiddleware
    from pydantic import BaseModel

    init_db()
    api = FastAPI(title="AllAIINC Multiplayer Relay", version="0.1")

    api.add_middleware(
        CORSMiddleware,
        allow_origins=[o.strip() for o in CORS_ORIGINS if o.strip()],
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
    )

    class CreateRoomIn(BaseModel):
        name: str = "Host"

    class JoinRoomIn(BaseModel):
        room: str
        name: str = "Player"

    class CmdIn(BaseModel):
        room: str
        token: str
        cmd: str

    class ActionIn(BaseModel):
        room: str
        token: str
        kind: str
        payload: Dict[str, Any] = {}

    # --- “Easy words” multiplayer language ---
    # verbs: say, put, get, add, del, who, list, ping, clear
    # all stored as events + public kv (plus private kv per player if needed)

    def parse_cmd(cmd: str):
        cmd = (cmd or "").strip()
        parts = cmd.split()
        verb = parts[0].lower() if parts else ""
        rest = parts[1:]
        return verb, rest

    @api.get("/api/health")
    def health():
        return {"ok": True, "t": now_i(), "db": DB_PATH}

    @api.post("/api/room/create")
    def room_create(body: CreateRoomIn):
        con = db()
        try:
            room = rid()
            token_ = tok()
            public = {"turnSeat": 0, "kv": {}, "joke": "Why did the packet cross the road? To get ACK’d. 🐔📨"}
            con.execute(
                "INSERT INTO rooms(room, created, seq, public_json) VALUES(?,?,?,?)",
                (room, now_i(), 0, json.dumps(public, ensure_ascii=False))
            )
            con.execute(
                "INSERT INTO players(token, room, seat, name, last_seen) VALUES(?,?,?,?,?)",
                (token_, room, 0, body.name[:24], now_i())
            )
            private_set(con, room, 0, {"kv": {}, "note": "host private pocket 🧥"})
            event_append(con, room, "join", {"seat": 0, "name": body.name[:24]})
            con.commit()
            return {"room": room, "token": token_, "seat": 0}
        finally:
            con.close()

    @api.post("/api/room/join")
    def room_join(body: JoinRoomIn):
        con = db()
        try:
            if not room_get(con, body.room):
                raise HTTPException(404, "Room not found")
            cleanup_inactive(con, body.room)

            # seat = smallest unused
            used = {int(r["seat"]) for r in con.execute("SELECT seat FROM players WHERE room=?", (body.room,)).fetchall()}
            seat = 0
            while seat in used:
                seat += 1

            token_ = tok()
            con.execute(
                "INSERT INTO players(token, room, seat, name, last_seen) VALUES(?,?,?,?,?)",
                (token_, body.room, seat, body.name[:24], now_i())
            )
            private_set(con, body.room, seat, {"kv": {}, "hand": []})
            seq = event_append(con, body.room, "join", {"seat": seat, "name": body.name[:24]})
            con.commit()
            return {"room": body.room, "token": token_, "seat": seat, "seq": seq}
        finally:
            con.close()

    @api.get("/api/state")
    def state(room: str, token: str, since: int = 0):
        con = db()
        try:
            if not room_get(con, room):
                raise HTTPException(404, "Room not found")
            p = player_by_token(con, token)
            if not p or p["room"] != room:
                raise HTTPException(401, "Bad token")
            con.execute("UPDATE players SET last_seen=? WHERE token=?", (now_i(), token))
            cleanup_inactive(con, room)

            pub = public_get(con, room)
            seat = int(p["seat"])
            priv = private_get(con, room, seat)

            evs = con.execute(
                "SELECT seq, t, kind, data_json FROM events WHERE room=? AND seq > ? ORDER BY seq",
                (room, since)
            ).fetchall()

            return {
                "seq": int(room_get(con, room)["seq"]),
                "you": {"seat": seat, "name": p["name"]},
                "roster": players_roster(con, room),
                "public": pub,
                "private": priv,
                "events": [{"seq": int(e["seq"]), "t": int(e["t"]), "kind": e["kind"], "data": json.loads(e["data_json"])} for e in evs],
            }
        finally:
            con.close()

    @api.post("/api/cmd")
    def cmd_run(body: CmdIn):
        con = db()
        try:
            if not room_get(con, body.room):
                raise HTTPException(404, "Room not found")
            p = player_by_token(con, body.token)
            if not p or p["room"] != body.room:
                raise HTTPException(401, "Bad token")

            seat = int(p["seat"])
            name = p["name"]
            con.execute("UPDATE players SET last_seen=? WHERE token=?", (now_i(), body.token))
            cleanup_inactive(con, body.room)

            pub = public_get(con, body.room)
            pub.setdefault("kv", {})
            priv = private_get(con, body.room, seat)
            priv.setdefault("kv", {})

            verb, rest = parse_cmd(body.cmd)

            if verb in ("help", ""):
                return {"ok": True, "msg": "verbs: join, say, put, get, add, del, who, list, ping, clear"}

            if verb == "ping":
                seq = event_append(con, body.room, "ping", {"seat": seat, "name": name})
                con.commit()
                return {"ok": True, "msg": "pong 🏓", "seq": seq}

            if verb == "who":
                return {"ok": True, "players": players_roster(con, body.room)}

            if verb == "list":
                return {"ok": True, "keys": sorted(pub["kv"].keys())}

            if verb == "say":
                msg = " ".join(rest).strip()[:240]
                if not msg:
                    raise HTTPException(400, "Usage: say <message>")
                seq = event_append(con, body.room, "say", {"seat": seat, "name": name, "text": msg})
                con.commit()
                return {"ok": True, "msg": "sent 🗣️", "seq": seq}

            if verb == "put":
                if len(rest) < 2:
                    raise HTTPException(400, "Usage: put <key> <value>")
                k = rest[0]
                v = " ".join(rest[1:])[:240]
                pub["kv"][k] = v
                public_set(con, body.room, pub)
                seq = event_append(con, body.room, "put", {"seat": seat, "key": k, "value": v})
                con.commit()
                return {"ok": True, "msg": f"ok ✅ stored {k}", "seq": seq}

            if verb == "get":
                if len(rest) != 1:
                    raise HTTPException(400, "Usage: get <key>")
                k = rest[0]
                return {"ok": True, "key": k, "value": pub["kv"].get(k)}

            if verb == "add":
                if len(rest) < 2:
                    raise HTTPException(400, "Usage: add <key> <number>")
                k = rest[0]
                try:
                    amt = float(rest[1])
                except:
                    raise HTTPException(400, "add needs a number, e.g. add score 5")
                cur = pub["kv"].get(k, 0)
                try:
                    cur = float(cur)
                except:
                    cur = 0.0
                pub["kv"][k] = cur + amt
                public_set(con, body.room, pub)
                seq = event_append(con, body.room, "add", {"seat": seat, "key": k, "amt": amt, "new": pub["kv"][k]})
                con.commit()
                return {"ok": True, "msg": f"{k} -> {pub['kv'][k]} 📈", "seq": seq}

            if verb == "del":
                if len(rest) != 1:
                    raise HTTPException(400, "Usage: del <key>")
                k = rest[0]
                pub["kv"].pop(k, None)
                public_set(con, body.room, pub)
                seq = event_append(con, body.room, "del", {"seat": seat, "key": k})
                con.commit()
                return {"ok": True, "msg": f"deleted {k} 🧹", "seq": seq}

            if verb == "clear":
                if seat != 0:
                    raise HTTPException(403, "Only seat 0 can clear")
                pub["kv"] = {}
                public_set(con, body.room, pub)
                seq = event_append(con, body.room, "clear", {"by": name})
                con.commit()
                return {"ok": True, "msg": "cleared 🧼", "seq": seq}

            raise HTTPException(400, f"Unknown verb: {verb}")
        finally:
            con.close()

    @api.post("/api/action")
    def action(body: ActionIn):
        # “action” is for structured game moves (turn-based etc.)
        con = db()
        try:
            if not room_get(con, body.room):
                raise HTTPException(404, "Room not found")
            p = player_by_token(con, body.token)
            if not p or p["room"] != body.room:
                raise HTTPException(401, "Bad token")

            seat = int(p["seat"])
            name = p["name"]
            con.execute("UPDATE players SET last_seen=? WHERE token=?", (now_i(), body.token))
            cleanup_inactive(con, body.room)

            pub = public_get(con, body.room)

            # ultra-minimal example: a shared “pot” with turn enforcement
            pub.setdefault("turnSeat", 0)
            pub.setdefault("pot", 0)

            if seat != int(pub["turnSeat"]):
                raise HTTPException(409, "Not your turn")

            if body.kind == "add_to_pot":
                amt = int(body.payload.get("amt", 1))
                pub["pot"] += max(0, amt)
            else:
                raise HTTPException(400, "Unknown kind")

            # advance turn
            seats = [r["seat"] for r in players_roster(con, body.room)]
            seats = sorted(int(s) for s in seats)
            i = seats.index(seat)
            pub["turnSeat"] = seats[(i+1) % len(seats)]

            public_set(con, body.room, pub)
            seq = event_append(con, body.room, "action", {"seat": seat, "name": name, "kind": body.kind, "payload": body.payload})
            con.commit()
            return {"ok": True, "seq": seq, "public": pub}
        finally:
            con.close()

# -----------------------------
# Streamlit admin mode 🧑‍🔧🧠
# -----------------------------
else:
    import streamlit as st
    import pandas as pd
    import requests

    init_db()

    st.set_page_config(page_title="Admin — Multiplayer Relay", layout="wide")
    st.title("🧑‍✈️ Admin Console — Multiplayer Relay")
    st.caption("If you can read this, nginx routing worked. If you can’t, blame gremlins. 👹")

    con = db()
    rooms = con.execute("SELECT room, created, seq FROM rooms ORDER BY created DESC").fetchall()
    con.close()

    if not rooms:
        st.info("No rooms yet. Create one via /api/room/create from your web client.")
        st.stop()

    df_rooms = pd.DataFrame([dict(r) for r in rooms])
    st.dataframe(df_rooms, use_container_width=True, hide_index=True)

    room_id = st.selectbox("Pick a room", df_rooms["room"].tolist())
    col1, col2, col3 = st.columns([1,1,1])

    if col1.button("🔄 Refresh"):
        st.rerun()

    # Show room details
    con = db()
    room = con.execute("SELECT * FROM rooms WHERE room=?", (room_id,)).fetchone()
    roster = con.execute("SELECT seat, name, last_seen FROM players WHERE room=? ORDER BY seat", (room_id,)).fetchall()
    events = con.execute("SELECT seq, t, kind, data_json FROM events WHERE room=? ORDER BY seq DESC LIMIT 80", (room_id,)).fetchall()
    con.close()

    st.subheader(f"🧩 Room `{room_id}`")
    st.write("**Public**")
    st.json(json.loads(room["public_json"]))

    st.write("**Players**")
    st.dataframe(pd.DataFrame([dict(r) for r in roster]), use_container_width=True, hide_index=True)

    st.write("**Recent events**")
    ev_df = pd.DataFrame([{
        "seq": int(e["seq"]), "t": int(e["t"]), "kind": e["kind"], "data": json.loads(e["data_json"])
    } for e in events])
    st.dataframe(ev_df, use_container_width=True, hide_index=True)

    st.caption("Joke: A SQL query walks into a bar and says: ‘Can I join you?’ 🍻🧾")