Update app.py (#27)

- Update app.py (ebaa58176e64a71f1b4f88866c71d4c5352219d9)

app.py

@@ -1,231 +1,825 @@
-import pandas as pd
-import streamlit as st
-import random
-import uuid
+# app.py
+"""
+Unified Online/Offline AI Quiz Game with Friends, Chat, Presence, Invites.
+
+- Offline: uses local JSON files under ./data/
+- Online: uses Firebase Realtime Database when configured (optional)
+- Put your Firebase service account JSON next to this file and name it serviceAccountKey.json
+- FIREBASE_DB_URL is set to your Firebase project's Realtime DB (from your screenshot)
+"""
+
 import os
-import json
+import uuid
 import time
-import requests  # For calling the Groq API
-import plotly.express as px
-import plotly.graph_objects as go
-from streamlit.components.v1 import html
-
-# Define file paths
-LEADERBOARD_FILE = "leaderboard.csv"
-GAME_DATA_FILE = "game_data.json"  
-PLAYERS_FILE = "players.json"  
+import json
+from datetime import datetime, timedelta
 
-# Groq API Configuration
-GROQ_API_KEY = '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'
-GROQ_API_URL = "https://api.groq.com/openai/v1/chat/completions"
+import streamlit as st
+import pandas as pd
+import random
+from streamlit.components.v1 import html
+import plotly.express as px
 
-# Define questions for multiple topics with at least 20 questions each
+# Try to import firebase-admin (optional). If unavailable, app will run Offline.
+try:
+    import firebase_admin
+    from firebase_admin import credentials, db
+    FIREBASE_AVAILABLE = True
+except Exception:
+    FIREBASE_AVAILABLE = False
+
+# ---------------- Page config ----------------
+st.set_page_config(page_title="AI Quiz Game — Online/Offline", layout="wide")
+
+# ---------------- Configuration ----------------
+DATA_DIR = "data"
+os.makedirs(DATA_DIR, exist_ok=True)
+
+# Local filenames
+GAMES_FILE = os.path.join(DATA_DIR, "games.json")
+PLAYERS_FILE = os.path.join(DATA_DIR, "players.json")
+MESSAGES_FILE = os.path.join(DATA_DIR, "messages.json")
+SESSIONS_FILE = os.path.join(DATA_DIR, "sessions.json")
+LEADERBOARD_FILE = os.path.join(DATA_DIR, "leaderboard.csv")
+FRIENDS_FILE = os.path.join(DATA_DIR, "friends.json")
+INBOX_FILE = os.path.join(DATA_DIR, "inbox.json")  # friend requests & invitations
+
+# Firebase defaults (you provided project)
+FIREBASE_CREDENTIALS = os.getenv("FIREBASE_CREDENTIALS", "serviceAccountKey.json")
+FIREBASE_DB_URL = os.getenv("FIREBASE_DB_URL", "https://real-time-database-fe632-default-rtdb.firebaseio.com/")
+
+# Heartbeat threshold (seconds) to consider a session active
+HEARTBEAT_THRESHOLD_SECONDS = 40
+
+# ---------------- Example Questions DB (expand as needed) ----------------
 questions_db = {
     "Geography": [
         ("What is the capital of France?", ["Paris", "London", "Berlin", "Madrid"], "Paris"),
-        ("What is the largest country in the world by land area?", ["Canada", "United States", "Russia", "China"], "Russia"),
-        ("Which river flows through Egypt?", ["Nile", "Amazon", "Ganges", "Yangtze"], "Nile"),
-        ("What is the capital of Japan?", ["Tokyo", "Kyoto", "Osaka", "Sapporo"], "Tokyo"),
-        ("Which is the smallest country in the world?", ["Monaco", "Vatican City", "San Marino", "Liechtenstein"], "Vatican City"),
-    ],
-    "Science": [
-        ("What is the chemical symbol for water?", ["H2O", "CO2", "O2", "H2"], "H2O"),
-        ("What is the powerhouse of the cell?", ["Nucleus", "Mitochondria", "Ribosome", "Endoplasmic Reticulum"], "Mitochondria"),
-        ("What planet is known as the Red Planet?", ["Venus", "Mars", "Jupiter", "Saturn"], "Mars"),
-        ("Who developed the theory of relativity?", ["Isaac Newton", "Albert Einstein", "Nikola Tesla", "Marie Curie"], "Albert Einstein"),
-        ("What is the largest organ in the human body?", ["Heart", "Skin", "Lungs", "Brain"], "Skin"),
+        ("Largest country by area?", ["Canada", "USA", "Russia", "China"], "Russia"),
+        ("River through Egypt?", ["Nile", "Amazon", "Ganges", "Yangtze"], "Nile"),
     ],
     "Math": [
-        ("What is 5 * 12?", ["50", "60", "55", "70"], "60"),
-        ("What is the square root of 64?", ["6", "7", "8", "9"], "8"),
-        ("What is 15 + 25?", ["35", "40", "45", "50"], "40"),
-        ("What is the value of pi?", ["3.14", "3.15", "3.16", "3.17"], "3.14"),
-        ("What is 20 / 4?", ["5", "6", "7", "8"], "5"),
+        ("5 * 12?", ["50", "60", "55", "70"], "60"),
+        ("sqrt(64)?", ["6","7","8","9"], "8"),
+        ("What is 15 + 25?", ["35","40","45","50"], "40"),
+    ],
+    "Science": [
+        ("H2O is?", ["Water","CO2","O2","H2"], "Water"),
+        ("Who developed relativity?", ["Newton","Einstein","Tesla","Curie"], "Einstein"),
     ],
     "IPL": [
-        ("Which IPL team won the 2020 IPL season?", ["Mumbai Indians", "Delhi Capitals", "Royal Challengers Bangalore", "Chennai Super Kings"], "Mumbai Indians"),
-        ("Who is the all-time highest run-scorer in IPL history?", ["Virat Kohli", "Rohit Sharma", "Suresh Raina", "Chris Gayle"], "Virat Kohli"),
-        ("Who won the first-ever IPL match?", ["Kolkata Knight Riders", "Royal Challengers Bangalore", "Chennai Super Kings", "Mumbai Indians"], "Kolkata Knight Riders"),
-        ("Which IPL team is known as the 'Yellow Army'?", ["Chennai Super Kings", "Mumbai Indians", "Delhi Capitals", "Sunrisers Hyderabad"], "Chennai Super Kings"),
-        ("Who hit the most sixes in the 2020 IPL season?", ["Shivam Dube", "AB de Villiers", "Ishan Kishan", "Kieron Pollard"], "Ishan Kishan"),
+        ("2020 IPL winner?", ["Mumbai Indians","Delhi Capitals","RCB","CSK"], "Mumbai Indians"),
+        ("Which team is called Yellow Army?", ["CSK","MI","DC","SRH"], "CSK")
     ]
 }
 
-# Function to load leaderboard from CSV file
-def load_leaderboard():
-    if os.path.exists(LEADERBOARD_FILE):
-        leaderboard_df = pd.read_csv(LEADERBOARD_FILE, names=['name', 'score', 'question', 'answer', 'correct', 'topic', 'avatar'], header=0)
-        return leaderboard_df
-    return pd.DataFrame(columns=['name', 'score', 'question', 'answer', 'correct', 'topic', 'avatar'])
-
-# Function to save leaderboard data to CSV
-def save_leaderboard(leaderboard_df):
-    leaderboard_df.to_csv(LEADERBOARD_FILE, index=False)
-
-# Function to create a new game
-def create_game():
-    game_id = str(uuid.uuid4())[:8]  # Generate a unique Game ID
-    selected_topics = st.multiselect("Choose Topics", list(questions_db.keys()))  # Topic selection
-    num_questions = st.selectbox("Select the number of questions", [5, 10, 15, 20])
-
-    if selected_topics:
-        # Collect questions from the selected topics
-        questions = []
-        questions_per_topic = num_questions // len(selected_topics)
-        
-        # Ensure we don't ask for more questions than are available
-        for topic in selected_topics:
-            available_questions = questions_db[topic]
-            if len(available_questions) < questions_per_topic:
-                st.warning(f"Not enough questions in {topic}. Only {len(available_questions)} questions available.")
-                questions_per_topic = len(available_questions)
-            
-            questions.extend(random.sample(available_questions, questions_per_topic))
-
-        random.shuffle(questions)  # Shuffle questions
-
-        game_data = {'game_id': game_id, 'topics': selected_topics, 'questions': questions}
-       
-        # Store the game data to a JSON file
-        if os.path.exists(GAME_DATA_FILE):
-            with open(GAME_DATA_FILE, "r") as file:
-                all_games = json.load(file)
+# ----------------- JSON helpers -----------------
+def load_json(path, default):
+    if os.path.exists(path):
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return default
+    return default
+
+def save_json(path, data):
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+# Ensure base files exist (local)
+base_defaults = {
+    GAMES_FILE: {},
+    PLAYERS_FILE: {},
+    MESSAGES_FILE: {},
+    SESSIONS_FILE: {},
+    FRIENDS_FILE: {},
+    INBOX_FILE: {}
+}
+for p, d in base_defaults.items():
+    if not os.path.exists(p):
+        save_json(p, d)
+if not os.path.exists(LEADERBOARD_FILE):
+    pd.DataFrame(columns=['name','score','game_id','topics','timestamp','avatar','questions','answers','correct_flags']).to_csv(LEADERBOARD_FILE, index=False)
+
+# ----------------- Firebase init -----------------
+def init_firebase_if_needed():
+    """Initialize Firebase Admin if available and credentials present. Return (ok,msg)."""
+    global FIREBASE_AVAILABLE
+    if not FIREBASE_AVAILABLE:
+        return False, "firebase-admin not installed"
+    if not FIREBASE_DB_URL:
+        return False, "FIREBASE_DB_URL not set"
+    if not os.path.exists(FIREBASE_CREDENTIALS):
+        return False, f"Service account file not found at {FIREBASE_CREDENTIALS}"
+    try:
+        if not firebase_admin._apps:
+            cred = credentials.Certificate(FIREBASE_CREDENTIALS)
+            firebase_admin.initialize_app(cred, {"databaseURL": FIREBASE_DB_URL})
+        return True, "Firebase initialized"
+    except Exception as e:
+        return False, f"Firebase init error: {e}"
+
+# Firebase helpers
+def fb_get(path):
+    try:
+        ref = db.reference(path)
+        return ref.get()
+    except Exception:
+        return None
+
+def fb_set(path, value):
+    ref = db.reference(path)
+    ref.set(value)
+
+def fb_push(path, value):
+    ref = db.reference(path).push()
+    ref.set(value)
+    return ref.key
+
+# ----------------- Unified DB API (Online or Offline) -----------------
+def local_get(collection):
+    if collection == "games":
+        return load_json(GAMES_FILE, {})
+    if collection == "players":
+        return load_json(PLAYERS_FILE, {})
+    if collection == "messages":
+        return load_json(MESSAGES_FILE, {})
+    if collection == "sessions":
+        return load_json(SESSIONS_FILE, {})
+    if collection == "friends":
+        return load_json(FRIENDS_FILE, {})
+    if collection == "inbox":
+        return load_json(INBOX_FILE, {})
+    if collection == "leaderboard":
+        try:
+            df = pd.read_csv(LEADERBOARD_FILE)
+            return df.to_dict(orient="records")
+        except Exception:
+            return []
+    return {}
+
+def local_set(collection, value):
+    if collection == "games":
+        save_json(GAMES_FILE, value)
+    elif collection == "players":
+        save_json(PLAYERS_FILE, value)
+    elif collection == "messages":
+        save_json(MESSAGES_FILE, value)
+    elif collection == "sessions":
+        save_json(SESSIONS_FILE, value)
+    elif collection == "friends":
+        save_json(FRIENDS_FILE, value)
+    elif collection == "inbox":
+        save_json(INBOX_FILE, value)
+    elif collection == "leaderboard":
+        try:
+            df = pd.DataFrame(value)
+            df.to_csv(LEADERBOARD_FILE, index=False)
+        except Exception:
+            pass
+
+def unified_get(collection):
+    mode = st.session_state.get("mode_selection", "Offline")
+    if mode == "Online":
+        ok, msg = init_firebase_if_needed()
+        if not ok:
+            return local_get(collection)
+        # map collection to firebase path
+        if collection == "games":
+            return fb_get("/games") or {}
+        if collection == "players":
+            return fb_get("/players") or {}
+        if collection == "messages":
+            return fb_get("/messages") or {}
+        if collection == "sessions":
+            return fb_get("/active_sessions") or {}
+        if collection == "friends":
+            return fb_get("/friends") or {}
+        if collection == "inbox":
+            return fb_get("/inbox") or {}
+        if collection == "leaderboard":
+            raw = fb_get("/leaderboard") or {}
+            if isinstance(raw, dict):
+                return list(raw.values())
+            return raw
+    else:
+        return local_get(collection)
+
+def unified_set(collection, data):
+    mode = st.session_state.get("mode_selection", "Offline")
+    if mode == "Online":
+        ok, msg = init_firebase_if_needed()
+        if not ok:
+            local_set(collection, data)
+            return
+        if collection == "games":
+            fb_set("/games", data); return
+        if collection == "players":
+            fb_set("/players", data); return
+        if collection == "messages":
+            fb_set("/messages", data); return
+        if collection == "sessions":
+            fb_set("/active_sessions", data); return
+        if collection == "friends":
+            fb_set("/friends", data); return
+        if collection == "inbox":
+            fb_set("/inbox", data); return
+        if collection == "leaderboard":
+            local_set(collection, data); return
+    else:
+        local_set(collection, data)
+
+def unified_push_message(game_id, msg_obj):
+    mode = st.session_state.get("mode_selection", "Offline")
+    if mode == "Online":
+        ok, _ = init_firebase_if_needed()
+        if ok:
+            fb_push(f"/messages/{game_id}", msg_obj)
+            return
+    all_msgs = unified_get("messages") or {}
+    game_msgs = all_msgs.get(game_id, [])
+    game_msgs.append(msg_obj)
+    if len(game_msgs) > 500:
+        game_msgs = game_msgs[-500:]
+    all_msgs[game_id] = game_msgs
+    unified_set("messages", all_msgs)
+
+def unified_push_leaderboard(row):
+    mode = st.session_state.get("mode_selection", "Offline")
+    if mode == "Online":
+        ok, _ = init_firebase_if_needed()
+        if ok:
+            fb_push("/leaderboard", row)
+            # also save local backup
+            try:
+                df = pd.read_csv(LEADERBOARD_FILE)
+            except Exception:
+                df = pd.DataFrame(columns=list(row.keys()))
+            df = pd.concat([df, pd.DataFrame([row])], ignore_index=True)
+            df.to_csv(LEADERBOARD_FILE, index=False)
+            return
+    # offline append CSV
+    try:
+        df = pd.read_csv(LEADERBOARD_FILE)
+    except Exception:
+        df = pd.DataFrame(columns=list(row.keys()))
+    df = pd.concat([df, pd.DataFrame([row])], ignore_index=True)
+    df.to_csv(LEADERBOARD_FILE, index=False)
+
+# ----------------- Session & Presence helpers -----------------
+def now_iso():
+    return datetime.utcnow().isoformat()
+
+def parse_iso(s):
+    try:
+        return datetime.fromisoformat(s)
+    except Exception:
+        return None
+
+def ensure_session_ids():
+    if "uid" not in st.session_state:
+        st.session_state['uid'] = str(uuid.uuid4())
+    if "session_id" not in st.session_state:
+        st.session_state['session_id'] = str(uuid.uuid4())
+ensure_session_ids()
+
+def claim_session_unified(game_id, username):
+    sessions = unified_get("sessions") or {}
+    game_sessions = sessions.get(game_id, {})
+    rec = game_sessions.get(username)
+    now = now_iso()
+    if rec is None:
+        game_sessions[username] = {"session_id": st.session_state['session_id'], "last_heartbeat": now}
+        sessions[game_id] = game_sessions
+        unified_set("sessions", sessions)
+        return True, ""
+    last = parse_iso(rec.get("last_heartbeat"))
+    if rec.get("session_id") == st.session_state['session_id']:
+        rec["last_heartbeat"] = now
+        game_sessions[username] = rec
+        sessions[game_id] = game_sessions
+        unified_set("sessions", sessions)
+        return True, ""
+    if last and (datetime.utcnow() - last) < timedelta(seconds=HEARTBEAT_THRESHOLD_SECONDS):
+        return False, "You are active in another tab/device. Return to that tab or wait."
+    # override stale
+    game_sessions[username] = {"session_id": st.session_state['session_id'], "last_heartbeat": now}
+    sessions[game_id] = game_sessions
+    unified_set("sessions", sessions)
+    return True, ""
+
+def heartbeat_unified(game_id, username):
+    sessions = unified_get("sessions") or {}
+    game_sessions = sessions.get(game_id, {})
+    rec = game_sessions.get(username, {})
+    rec["session_id"] = st.session_state['session_id']
+    rec["last_heartbeat"] = now_iso()
+    game_sessions[username] = rec
+    sessions[game_id] = game_sessions
+    unified_set("sessions", sessions)
+
+# ----------------- Friends & Inbox helpers -----------------
+def get_friends_map():
+    return unified_get("friends") or {}
+
+def save_friends_map(m):
+    unified_set("friends", m)
+
+def get_inbox():
+    return unified_get("inbox") or {}
+
+def save_inbox(i):
+    unified_set("inbox", i)
+
+def send_friend_request(from_user, to_user):
+    inbox = get_inbox()
+    user_inbox = inbox.get(to_user, [])
+    user_inbox.append({"type":"friend_request","from":from_user,"ts":now_iso()})
+    inbox[to_user] = user_inbox
+    save_inbox(inbox)
+
+def accept_friend_request(current_user, from_user):
+    friends = get_friends_map()
+    friends.setdefault(current_user, [])
+    friends.setdefault(from_user, [])
+    if from_user not in friends[current_user]:
+        friends[current_user].append(from_user)
+    if current_user not in friends[from_user]:
+        friends[from_user].append(current_user)
+    save_friends_map(friends)
+    # remove request
+    inbox = get_inbox()
+    entries = inbox.get(current_user, [])
+    entries = [e for e in entries if not (e.get('type')=='friend_request' and e.get('from')==from_user)]
+    inbox[current_user] = entries
+    save_inbox(inbox)
+
+def send_game_invite(from_user, to_user, game_id):
+    inbox = get_inbox()
+    user_inbox = inbox.get(to_user, [])
+    user_inbox.append({"type":"invite","from":from_user,"game_id":game_id,"ts":now_iso()})
+    inbox[to_user] = user_inbox
+    save_inbox(inbox)
+
+# ----------------- Game helpers -----------------
+def create_game(host_name, topics, num_questions=5, auto_close=True):
+    games = unified_get("games") or {}
+    pool = []
+    for t in topics:
+        pool += questions_db.get(t, [])
+    if len(pool) < num_questions:
+        num_questions = len(pool)
+    questions = random.sample(pool, num_questions)
+    game_id = str(uuid.uuid4())[:8]
+    game_obj = {
+        "game_id": game_id,
+        "host": host_name,
+        "topics": topics,
+        "questions": questions,
+        "created_at": now_iso(),
+        "closed": False,
+        "auto_close_on_submit": bool(auto_close)
+    }
+    games[game_id] = game_obj
+    unified_set("games", games)
+    players = unified_get("players") or {}
+    players[game_id] = players.get(game_id, {})
+    unified_set("players", players)
+    msgs = unified_get("messages") or {}
+    msgs[game_id] = msgs.get(game_id, [])
+    unified_set("messages", msgs)
+    return game_id
+
+def join_game(game_id, username, avatar):
+    games = unified_get("games") or {}
+    if game_id not in games:
+        return False, "Invalid Game ID"
+    if games[game_id].get("closed"):
+        return False, "Game is closed"
+    players = unified_get("players") or {}
+    game_players = players.get(game_id, {})
+    if username in game_players:
+        game_players[username]['avatar'] = avatar
+        game_players[username]['last_joined'] = now_iso()
+    else:
+        game_players[username] = {"avatar": avatar, "joined_at": now_iso(), "submitted": False}
+    players[game_id] = game_players
+    unified_set("players", players)
+    ok, msg = claim_session_unified(game_id, username)
+    if ok:
+        players = unified_get("players") or {}
+        players[game_id][username]['last_heartbeat'] = now_iso()
+        unified_set("players", players)
+    return ok, msg
+
+def compute_score(questions, answers, times):
+    total = 0
+    flags = []
+    for i, q in enumerate(questions):
+        ans = answers[i] if i < len(answers) else ""
+        try:
+            correct = str(ans).strip().lower() == str(q[2]).strip().lower()
+        except Exception:
+            correct = False
+        if correct:
+            base = 10
+            t = times[i] if i < len(times) and times[i] else 999
+            bonus = max(0, int((max(0, 15 - min(t,15)) / 15) * 5))
+            total += base + bonus
+            flags.append("Yes")
         else:
-            all_games = {}
-
-        all_games[game_id] = game_data
-
-        with open(GAME_DATA_FILE, "w") as file:
-            json.dump(all_games, file)
-
-        st.success(f"Game created successfully! Game ID: {game_id}")
-        return game_id, selected_topics, questions
+            flags.append("No")
+    return total, flags
+
+# ----------------- UI -----------------
+st.sidebar.title("Mode & Profile")
+mode_choice = st.sidebar.selectbox("Mode", ["Offline (local JSON)", "Online (Firebase)"], index=0)
+st.session_state['mode_selection'] = "Online" if mode_choice.startswith("Online") else "Offline"
+
+# If user chose Online, attempt to init and show feedback
+if st.session_state['mode_selection'] == "Online":
+    ok, msg = init_firebase_if_needed()
+    if not ok:
+        st.sidebar.error(f"Online init failed: {msg}. Working Offline.")
+        st.session_state['mode_selection'] = "Offline"
     else:
-        st.error("Please select at least one topic.")
-
-# Function to join a game
-def join_game():
-    game_id = st.text_input("Enter Game ID to join:")
-
-    if game_id:
-        with open(GAME_DATA_FILE, "r") as file:
-            all_games = json.load(file)
-
-        if game_id in all_games:
-            game_data = all_games[game_id]
-            st.session_state['game_data'] = game_data
-            st.success(f"Joined game with ID: {game_id}")
-            start_game(game_data)  # Start the game with the joined data
+        st.sidebar.success("Online (Firebase) ready.")
+
+st.sidebar.markdown("### You")
+uname = st.sidebar.text_input("Your name", value=st.session_state.get("username",""))
+avat = st.sidebar.selectbox("Avatar", ["🎮","🐱","🐶","🦄","👽","🎩"], index=0)
+st.session_state['username'] = uname or st.session_state.get("username","")
+st.session_state['avatar'] = avat or st.session_state.get("avatar","🎮")
+
+if st.sidebar.button("Refresh"):
+    st.experimental_rerun()
+
+page = st.sidebar.selectbox("Page", ["Home","Create Game","Join Game","Play","Friends","Inbox","Leaderboard"], index=0)
+st.title("AI Quiz Game — Online/Offline (Friends & Chat)")
+
+def render_copy_button(val, key):
+    copy_html = f'''
+    <div style="display:flex;gap:8px;align-items:center;">
+      <input id="gid_{key}" value="{val}" readonly style="padding:6px;border:1px solid #ddd;border-radius:6px;">
+      <button onclick="navigator.clipboard.writeText(document.getElementById('gid_{key}').value)" style="padding:6px 10px;border-radius:6px;cursor:pointer;">Copy</button>
+    </div>
+    '''
+    html(copy_html)
+
+# Home page
+def home_page():
+    st.header("Home")
+    st.write("Create games, invite friends, play and climb the leaderboard.")
+    if st.session_state.get('last_score') is not None:
+        st.success(f"Your last score: {st.session_state.get('last_score')} (Game {st.session_state.get('last_game')})")
+
+    sessions = unified_get("sessions") or {}
+    active_list = []
+    threshold = timedelta(seconds=HEARTBEAT_THRESHOLD_SECONDS)
+    for gid, users in (sessions or {}).items():
+        for uname, rec in (users or {}).items():
+            last = parse_iso(rec.get('last_heartbeat'))
+            if last and (datetime.utcnow() - last) < threshold:
+                active_list.append((gid, uname, rec.get('last_heartbeat')))
+    st.subheader("Active players (recent)")
+    st.markdown(f"**{len(active_list)} players active now**")
+    for gid, uname, ts in active_list[:50]:
+        st.write(f"• **{uname}** (Game: {gid}) — last {ts}")
+
+    st.markdown("---")
+    games = unified_get("games") or {}
+    players_map = unified_get("players") or {}
+    st.subheader("Recent games")
+    for g in sorted(list(games.values()), key=lambda x: x.get("created_at",""), reverse=True)[:10]:
+        gid = g.get("game_id")
+        st.markdown(f"### 🎮 Game: **{gid}** {'(Closed)' if g.get('closed') else ''}")
+        st.write(f"Host: {g.get('host')} — Topics: {', '.join(g.get('topics',[]))}")
+        st.write(f"Created: {g.get('created_at')}")
+        players_here = players_map.get(gid, {}) or {}
+        st.write(f"Players joined: **{len(players_here)}**")
+        if players_here:
+            for uname_p, info in players_here.items():
+                status = "✅ Submitted" if info.get('submitted') else "⏳ Playing"
+                st.write(f"{info.get('avatar','🎮')} **{uname_p}** — {status}")
+        if not g.get('closed'):
+            st.info(f"Share this Game ID: {gid}")
+            render_copy_button(gid, gid)
+            if st.session_state.get('username'):
+                if st.button(f"Invite your friends to {gid}", key=f"invite_{gid}"):
+                    friends = get_friends_map().get(st.session_state['username'], [])
+                    if not friends:
+                        st.warning("No friends to invite.")
+                    else:
+                        for f in friends:
+                            send_game_invite(st.session_state['username'], f, gid)
+                        st.success("Invites sent to friends.")
+        if st.button(f"Challenge friends with a new game like {gid}", key=f"challenge_{gid}"):
+            new_id = create_game(st.session_state.get('username','Host'), g.get('topics',[]), num_questions=len(g.get('questions',[])))
+            st.success(f"Challenge created: {new_id}")
+        st.markdown("---")
+
+# Create game
+def create_game_page():
+    st.header("Create Game")
+    host = st.text_input("Host name", value=st.session_state.get("username",""))
+    topics = st.multiselect("Topics", list(questions_db.keys()))
+    num_q = st.selectbox("Number of questions", [5,10,15,20], index=0)
+    auto_close = st.checkbox("Auto-close when someone submits", value=True)
+    if st.button("Create Game"):
+        if not host or not topics:
+            st.error("Enter host and choose topics.")
+        else:
+            gid = create_game(host, topics, num_q, auto_close)
+            st.success(f"Created game: {gid}")
+            st.session_state['game_id'] = gid
+            st.session_state['username'] = host
+            st.session_state['avatar'] = st.session_state.get('avatar','🎮')
+            st.session_state['is_host'] = True
+
+# Join game
+def join_game_page():
+    st.header("Join Game")
+    gid = st.text_input("Game ID", value=st.session_state.get('game_id',''))
+    uname = st.text_input("Your name", value=st.session_state.get('username',''))
+    avatar = st.selectbox("Avatar", ["🎮","🐱","🐶","🦄","👽","🎩"], index=0)
+    if st.button("Join"):
+        if not gid or not uname:
+            st.error("Provide Game ID and name.")
         else:
-            st.error("Invalid Game ID. Please check and try again.")
-
-# Function to start the game
-def start_game(game_data):
-    topics = game_data['topics']
-    questions = game_data['questions']
-
-    username = st.text_input("Enter your name:")
-    avatar = st.selectbox("Choose your Avatar", ["🐱", "🐶", "🦄", "👽", "🎮"])
-    st.session_state['avatar'] = avatar
-
-    if username:
-        if 'answers' not in st.session_state:
-            st.session_state['answers'] = [""] * len(questions)
-       
-        score = 0
-        current_question = 0
-        while current_question < len(questions):
-            question, options, correct_answer = questions[current_question]
-            topic = next(topic for topic in topics if any(q[0] == question for q in questions_db[topic]))
-
-            if current_question not in st.session_state.get('options', {}):
-                st.session_state['options'] = {current_question: options}
-
-            options = st.session_state['options'][current_question]
-            answer = st.radio(f"Question {current_question+1}: {question}", options, key=f"q{current_question}")
-            st.session_state['answers'][current_question] = answer
-
-            with st.empty():
-                timer_text = st.empty()
-                for time_left in range(10, 0, -1):
-                    timer_text.text(f"Time left for this question: {time_left} seconds")
-                    time.sleep(1)
-           
-            # Display Correct or Incorrect after the timer ends
-            if answer == correct_answer:
-                st.write("Correct!")
-                score += 10
+            ok, msg = join_game(gid, uname, avatar)
+            if not ok:
+                st.error(msg)
             else:
-                st.write(f"Incorrect! The correct answer is: {correct_answer}")
-
-            current_question += 1
-
-        submit_button = st.button("Submit Answers")
-        if submit_button:
-            leaderboard_df = load_leaderboard()
-            new_row = pd.DataFrame({
-                'name': [username],
-                'score': [score],
-                'question': [', '.join([q[0] for q in questions])],
-                'answer': [', '.join(st.session_state['answers'])],
-                'correct': [', '.join(['Yes' if st.session_state['answers'][i].strip().lower() == questions[i][2].lower() else 'No' for i in range(len(st.session_state['answers']))])],
-                'topic': [', '.join(topics)],
-                'avatar': [avatar]
-            })
-
-            leaderboard_df = pd.concat([leaderboard_df, new_row], ignore_index=True)
-            leaderboard_df = leaderboard_df.sort_values(by='score', ascending=False).reset_index(drop=True)
-            save_leaderboard(leaderboard_df)
-
-            st.success(f"Game Over! Your final score is {score}")
-
-# Function to display the leaderboard with animations
-def display_dashboard():
-    leaderboard_df = load_leaderboard()
-
-    st.subheader("Top 3 Players")
-    top_3 = leaderboard_df.head(3)
-   
-    # First Place Winner - Celebration Animation
-    first_place = top_3.iloc[0] if not leaderboard_df.empty else None
-    if first_place is not None:
-        st.write(f"🏆 {first_place['name']} - {first_place['score']} points! 🎉 {first_place['avatar']}")
-        st.markdown("<h3 style='color: gold;'>🎉 Congratulations on First Place! 🎉</h3>", unsafe_allow_html=True)
-        html_code = f"""
-        <div style="text-align: center;">
-            <h2>🏆 Winner: {first_place['name']} 🏆</h2>
-            <p>Score: {first_place['score']}</p>
-            <p>Avatar: {first_place['avatar']}</p>
-        </div>
-        <div id="balloon" style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);">
-            <img src="https://upload.wikimedia.org/wikipedia/commons/thumb/4/44/Yellow_balloon.svg/1024px-Yellow_balloon.svg.png" width="150" alt="Balloon" />
-        </div>
-        """
-        html(html_code)
-        st.balloons()
-
-    st.write("Top 3 Players:")
-    for index, row in top_3.iterrows():
-        st.write(f"{row['name']} - {row['score']} points! {row['avatar']}")
-
-# Main function to handle Streamlit app
-def main():
-    st.title('AI Quiz Game')
-
-    mode = st.sidebar.selectbox("Select Mode", ["Home", "Create Game", "Join Game", "Leaderboard"])
-
-    if mode == "Home":
-        st.write("Welcome to the Game!")
-        st.write("You can create a new game, join an existing game, or check the leaderboard.")
-
-    elif mode == "Create Game":
-        create_game()
-
-    elif mode == "Join Game":
-        join_game()
-
-    elif mode == "Leaderboard":
-        display_dashboard()
-
-if __name__ == "__main__":
-    main()
+                st.success("Joined game.")
+                st.session_state['game_id'] = gid
+                st.session_state['username'] = uname
+                st.session_state['avatar'] = avatar
+                st.session_state['is_host'] = (unified_get("games") or {}).get(gid, {}).get("host") == uname
+                g = unified_get("games") or {}
+                st.session_state['game_questions'] = g[gid]['questions']
+                st.session_state['current_index'] = 0
+                st.session_state['answers'] = [""] * len(st.session_state['game_questions'])
+                st.session_state['answer_times'] = [None] * len(st.session_state['game_questions'])
+                st.experimental_rerun()
+
+# Play page
+def play_page():
+    st.header("Play")
+    gid = st.session_state.get('game_id')
+    uname = st.session_state.get('username')
+    avatar = st.session_state.get('avatar','🎮')
+    if not gid or not uname:
+        st.info("Join a game first.")
+        return
+
+    ok, msg = claim_session_unified(gid, uname)
+    if not ok:
+        st.error(msg)
+        return
+
+    heartbeat_unified(gid, uname)
+
+    games = unified_get("games") or {}
+    game = games.get(gid)
+    if not game:
+        st.error("Game not found.")
+        return
+    if game.get('closed'):
+        st.error("Game closed.")
+        return
+
+    questions = st.session_state.get('game_questions', game.get('questions', []))
+    if not questions:
+        st.error("No questions loaded.")
+        return
+
+    idx = st.session_state.get('current_index', 0)
+    if idx >= len(questions):
+        st.success("All done — submit!")
+        return
+
+    q = questions[idx]
+    st.subheader(f"Question {idx+1}/{len(questions)}")
+    st.write(q[0])
+    if 'question_started_at' not in st.session_state:
+        st.session_state['question_started_at'] = time.time()
+    choice = st.radio("Choose an answer:", q[1], key=f"choice_{idx}")
+    elapsed = int(time.time() - st.session_state['question_started_at'])
+    time_limit = 15
+    st.markdown(f"**Time left:** {max(0, time_limit - elapsed)} seconds")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("Next"):
+            taken = time.time() - st.session_state['question_started_at']
+            answers = st.session_state.get('answers', [""]*len(questions))
+            times = st.session_state.get('answer_times', [None]*len(questions))
+            answers[idx] = choice
+            times[idx] = taken
+            st.session_state['answers'] = answers
+            st.session_state['answer_times'] = times
+            st.session_state['current_index'] = idx + 1
+            st.session_state['question_started_at'] = None
+            players = unified_get("players") or {}
+            if players.get(gid, {}).get(uname):
+                players[gid][uname]['last_heartbeat'] = now_iso()
+                unified_set("players", players)
+            heartbeat_unified(gid, uname)
+            st.experimental_rerun()
+
+    with col2:
+        if idx == len(questions)-1:
+            if st.button("Submit All Answers"):
+                answers = st.session_state.get('answers', [""]*len(questions))
+                times = st.session_state.get('answer_times', [None]*len(questions))
+                answers[idx] = choice
+                times[idx] = time.time() - st.session_state['question_started_at'] if st.session_state.get('question_started_at') else None
+                st.session_state['answers'] = answers
+                st.session_state['answer_times'] = times
+                score, flags = compute_score(questions, answers, times)
+                now = now_iso()
+                row = {
+                    "name": uname,
+                    "score": score,
+                    "game_id": gid,
+                    "topics": ",".join(game.get('topics',[])),
+                    "timestamp": now,
+                    "avatar": avatar,
+                    "questions": " || ".join([q[0] for q in questions]),
+                    "answers": " || ".join([str(a) for a in answers]),
+                    "correct_flags": " || ".join(flags)
+                }
+                unified_push_leaderboard(row)
+                players = unified_get("players") or {}
+                if players.get(gid) and players[gid].get(uname):
+                    players[gid][uname]['submitted'] = True
+                    players[gid][uname]['submitted_at'] = now
+                    unified_set("players", players)
+                if game.get('auto_close_on_submit', True):
+                    games[gid]['closed'] = True
+                    games[gid]['closed_at'] = now
+                    unified_set("games", games)
+                st.success(f"Submitted! Score: {score}")
+                st.balloons()
+                st.session_state['last_score'] = score
+                st.session_state['last_game'] = gid
+                st.session_state['current_index'] = 0
+                st.experimental_rerun()
+
+    st.markdown("---")
+    st.subheader("Game Chat")
+    msgs = unified_get("messages") or {}
+    game_msgs = msgs.get(gid, []) if isinstance(msgs, dict) else msgs
+    for m in game_msgs[-100:]:
+        st.write(f"**{m.get('user')}** [{m.get('ts')}]: {m.get('text')}")
+    new_msg = st.text_input("Send message to game", key=f"chat_{gid}")
+    if st.button("Send", key=f"send_{gid}"):
+        if new_msg and new_msg.strip():
+            unified_push_message(gid, {"user": uname, "text": new_msg.strip(), "ts": now_iso()})
+            heartbeat_unified(gid, uname)
+            st.experimental_rerun()
+
+# Friends page
+def friends_page():
+    st.header("Friends")
+    user = st.session_state.get('username')
+    if not user:
+        st.info("Enter your name in the sidebar to use Friends.")
+        return
+    friends_map = get_friends_map()
+    your_friends = friends_map.get(user, [])
+    st.subheader("Your friends")
+    if your_friends:
+        for f in your_friends:
+            sessions = unified_get("sessions") or {}
+            status = "offline"
+            for gid, users in (sessions or {}).items():
+                rec = users.get(f)
+                if rec:
+                    last = parse_iso(rec.get('last_heartbeat'))
+                    if last and (datetime.utcnow() - last) < timedelta(seconds=HEARTBEAT_THRESHOLD_SECONDS):
+                        status = "online"
+                        break
+            st.write(f"• {f} — **{status}**")
+            if st.button(f"Invite {f} to a game", key=f"invitebtn_{f}"):
+                gid = st.text_input(f"Enter game id to invite {f} (or leave blank to create)", key=f"inviteinput_{f}")
+                if gid:
+                    send_game_invite(st.session_state['username'], f, gid)
+                    st.success(f"Invite sent to {f} for game {gid}")
+                else:
+                    topics = list(questions_db.keys())[:1]
+                    new_id = create_game(st.session_state['username'], topics, num_questions=5)
+                    send_game_invite(st.session_state['username'], f, new_id)
+                    st.success(f"Invite sent to {f} for new game {new_id}")
+    else:
+        st.write("You have no friends yet.")
+
+    st.markdown("---")
+    st.subheader("Find / Add friends")
+    all_users = set()
+    players = unified_get("players") or {}
+    for gid, users in (players or {}).items():
+        for u in (users or {}).keys():
+            all_users.add(u)
+    all_users = all_users.union(set(get_friends_map().keys()))
+    all_users.discard(user)
+    candidate = st.text_input("Search user to add (exact name)", value="")
+    if st.button("Send Friend Request"):
+        if not candidate:
+            st.error("Enter user name")
+        else:
+            send_friend_request(user, candidate)
+            st.success("Friend request sent.")
+
+# Inbox page
+def inbox_page():
+    st.header("Inbox")
+    user = st.session_state.get('username')
+    if not user:
+        st.info("Enter your name in the sidebar to view Inbox.")
+        return
+    inbox = get_inbox()
+    items = inbox.get(user, [])
+    if not items:
+        st.write("No messages.")
+        return
+    for idx, item in enumerate(items[:50]):
+        t = item.get('type')
+        if t == "friend_request":
+            fr = item.get('from')
+            st.write(f"Friend request from **{fr}** at {item.get('ts')}")
+            if st.button(f"Accept {idx}"):
+                accept_friend_request(user, fr)
+                st.success(f"You are now friends with {fr}")
+                st.experimental_rerun()
+            if st.button(f"Reject {idx}"):
+                entries = [it for it in items if not (it.get('type')=='friend_request' and it.get('from')==fr)]
+                inbox[user] = entries
+                save_inbox(inbox)
+                st.success("Rejected")
+                st.experimental_rerun()
+        elif t == "invite":
+            fr = item.get('from'); gid = item.get('game_id')
+            st.write(f"Invite from **{fr}** to join game **{gid}** at {item.get('ts')}")
+            if st.button(f"Join Invite {idx}"):
+                ok, msg = join_game(gid, user, st.session_state.get('avatar','🎮'))
+                if ok:
+                    st.success(f"Joined game {gid}")
+                    items = [it for it in items if not (it.get('type')=='invite' and it.get('from')==fr and it.get('game_id')==gid)]
+                    inbox[user] = items
+                    save_inbox(inbox)
+                    st.session_state['game_id'] = gid
+                    st.session_state['username'] = user
+                    st.experimental_rerun()
+                else:
+                    st.error(msg)
+
+# Leaderboard page
+def leaderboard_page():
+    st.header("Leaderboard")
+    rows = unified_get("leaderboard") or []
+    if isinstance(rows, list) and rows:
+        df = pd.DataFrame(rows)
+    else:
+        try:
+            df = pd.read_csv(LEADERBOARD_FILE)
+        except Exception:
+            df = pd.DataFrame()
+    if df.empty:
+        st.info("No scores yet.")
+        return
+    st.dataframe(df.sort_values(by="score", ascending=False).head(200))
+    fig = px.bar(df.sort_values('score', ascending=False).head(10), x='name', y='score')
+    st.plotly_chart(fig, use_container_width=True)
+
+# Route pages
+if page == "Home":
+    home_page()
+elif page == "Create Game":
+    create_game_page()
+elif page == "Join Game":
+    join_game_page()
+elif page == "Play":
+    play_page()
+elif page == "Friends":
+    friends_page()
+elif page == "Inbox":
+    inbox_page()
+elif page == "Leaderboard":
+    leaderboard_page()
+
+# Resume quick action
+if st.session_state.get('game_id') and st.session_state.get('username'):
+    players = unified_get("players") or {}
+    info = players.get(st.session_state['game_id'], {}).get(st.session_state['username'], {}) if players.get(st.session_state.get('game_id')) else {}
+    if info and info.get('submitted'):
+        st.info("You already submitted this game.")
+    else:
+        with st.expander("Resume Game"):
+            if st.button("Go to Play"):
+                st.experimental_rerun()
+
+st.markdown("---")
+st.write("Notes: Online mode requires firebase-admin and service account JSON named 'serviceAccountKey.json' placed next to app.py. Offline mode stores data in ./data/.")
+