app.py

import streamlit as st
import asyncio
import websockets
import uuid
import argparse
from datetime import datetime
import os
import random
import time
import hashlib
from PIL import Image
import glob
import base64
import io
import streamlit.components.v1 as components
import edge_tts
import nest_asyncio
import re
from streamlit_paste_button import paste_image_button
import pytz
import shutil
from urllib.parse import urlencode
from PyPDF2 import PdfReader
import json

# Patch for nested async - sneaky fix! 🐍✨
nest_asyncio.apply()

# Static config - constants rule! 📏👑
icons = '🤖🧠🔬📝'
START_ROOM = "Sector 🌌"

# Page setup - dressing up the window! 🖼️🎀
st.set_page_config(
    page_title="🤖🧠MMO Chat Brain📝🔬",
    page_icon=icons,
    layout="wide",
    initial_sidebar_state="auto"
)

# Funky usernames with corresponding Edge TTS voices
FUN_USERNAMES = {
    "CosmicJester 🌌": "en-US-AriaNeural",
    "PixelPanda 🐼": "en-US-JennyNeural",
    "QuantumQuack 🦆": "en-GB-SoniaNeural",
    "StellarSquirrel 🐿️": "en-AU-NatashaNeural",
    "GizmoGuru ⚙️": "en-CA-ClaraNeural",
    "NebulaNinja 🌠": "en-US-GuyNeural",
    "ByteBuster 💾": "en-GB-RyanNeural",
    "GalacticGopher 🌍": "en-AU-WilliamNeural",
    "RocketRaccoon 🚀": "en-CA-LiamNeural",
    "EchoElf 🧝": "en-US-AnaNeural",
    "PhantomFox 🦊": "en-US-BrandonNeural",
    "WittyWizard 🧙": "en-GB-ThomasNeural",
    "LunarLlama 🌙": "en-AU-FreyaNeural",
    "SolarSloth ☀️": "en-CA-LindaNeural",
    "AstroAlpaca 🦙": "en-US-ChristopherNeural",
    "CyberCoyote 🐺": "en-GB-ElliotNeural",
    "MysticMoose 🦌": "en-AU-JamesNeural",
    "GlitchGnome 🧚": "en-CA-EthanNeural",
    "VortexViper 🐍": "en-US-AmberNeural",
    "ChronoChimp 🐒": "en-GB-LibbyNeural"
}

# Top-level files (no subdirectories)
CHAT_FILE = "global_chat.md"
QUOTE_VOTES_FILE = "quote_votes.md"
MEDIA_VOTES_FILE = "media_votes.md"
HISTORY_FILE = "chat_history.md"
STATE_FILE = "user_state.txt"

# Fancy digits - numbers got style! 🔢💃
UNICODE_DIGITS = {i: f"{i}\uFE0F⃣" for i in range(10)}

# Massive font collection - typography bonanza! 🖋️🎨
UNICODE_FONTS = [
    ("Normal", lambda x: x),
    ("Bold", lambda x: "".join(chr(ord(c) + 0x1D400 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D41A - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Italic", lambda x: "".join(chr(ord(c) + 0x1D434 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D44E - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Bold Italic", lambda x: "".join(chr(ord(c) + 0x1D468 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D482 - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Script", lambda x: "".join(chr(ord(c) + 0x1D49C - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D4B6 - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Bold Script", lambda x: "".join(chr(ord(c) + 0x1D4D0 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D4EA - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Fraktur", lambda x: "".join(chr(ord(c) + 0x1D504 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D51E - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Bold Fraktur", lambda x: "".join(chr(ord(c) + 0x1D56C - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D586 - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Double Struck", lambda x: "".join(chr(ord(c) + 0x1D538 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D552 - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Sans Serif", lambda x: "".join(chr(ord(c) + 0x1D5A0 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D5BA - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Sans Serif Bold", lambda x: "".join(chr(ord(c) + 0x1D5D4 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D5EE - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Sans Serif Italic", lambda x: "".join(chr(ord(c) + 0x1D608 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D622 - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Sans Serif Bold Italic", lambda x: "".join(chr(ord(c) + 0x1D63C - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D656 - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Monospace", lambda x: "".join(chr(ord(c) + 0x1D670 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D68A - 0x61) if 'a' <= c <= 'z' else c for c in x)),
    ("Circled", lambda x: "".join(chr(ord(c) - 0x41 + 0x24B6) if 'A' <= c <= 'Z' else chr(ord(c) - 0x61 + 0x24D0) if 'a' <= c <= 'z' else c for c in x)),
    ("Squared", lambda x: "".join(chr(ord(c) - 0x1F130 - 0x41) if 'A' <= c <= 'Z' else c for c in x)),
    ("Negative Circled", lambda x: "".join(chr(ord(c) - 0x41 + 0x1F150) if 'A' <= c <= 'Z' else c for c in x)),
    ("Negative Squared", lambda x: "".join(chr(ord(c) - 0x41 + 0x1F170) if 'A' <= c <= 'Z' else c for c in x)),
    ("Regional Indicator", lambda x: "".join(chr(ord(c) - 0x41 + 0x1F1E6) if 'A' <= c <= 'Z' else c for c in x)),
]

# Global state - keeping tabs! 🌍📋
if 'server_running' not in st.session_state:
    st.session_state.server_running = False
if 'server_task' not in st.session_state:
    st.session_state.server_task = None
if 'active_connections' not in st.session_state:
    st.session_state.active_connections = {}
if 'media_notifications' not in st.session_state:
    st.session_state.media_notifications = []
if 'last_chat_update' not in st.session_state:
    st.session_state.last_chat_update = 0
if 'displayed_chat_lines' not in st.session_state:
    st.session_state.displayed_chat_lines = []
if 'message_text' not in st.session_state:
    st.session_state.message_text = ""
if 'audio_cache' not in st.session_state:
    st.session_state.audio_cache = {}
if 'pasted_image_data' not in st.session_state:
    st.session_state.pasted_image_data = None
if 'quote_line' not in st.session_state:
    st.session_state.quote_line = None
if 'refresh_rate' not in st.session_state:
    st.session_state.refresh_rate = 5
if 'base64_cache' not in st.session_state:
    st.session_state.base64_cache = {}
if 'image_hashes' not in st.session_state:
    st.session_state.image_hashes = set()
if 'gallery_columns' not in st.session_state:
    st.session_state.gallery_columns = 1
if 'user_id' not in st.session_state:
    st.session_state.user_id = None
if 'user_hash' not in st.session_state:
    st.session_state.user_hash = None

# Timestamp wizardry - clock ticks with flair! ⏰🎩
def format_timestamp_prefix(username):
    central = pytz.timezone('US/Central')
    now = datetime.now(central)
    return f"{now.strftime('%I-%M-%p-ct-%m-%d-%Y')}-by-{username}"

# Compute image hash from binary data
def compute_image_hash(image_data):
    if isinstance(image_data, Image.Image):
        img_byte_arr = io.BytesIO()
        image_data.save(img_byte_arr, format='PNG')
        img_bytes = img_byte_arr.getvalue()
    else:
        img_bytes = image_data
    return hashlib.md5(img_bytes).hexdigest()[:8]

# Node naming - christening the beast! 🌐🍼
def get_node_name():
    parser = argparse.ArgumentParser(description='Start a chat node with a specific name')
    parser.add_argument('--node-name', type=str, default=None)
    parser.add_argument('--port', type=int, default=8501)
    args = parser.parse_args()
    username = st.session_state.get('username', 'System 🌟')
    log_action(username, "🌐🍼 - Node naming - christening the beast!")
    return args.node_name or f"node-{uuid.uuid4().hex[:8]}", args.port

# Action logger - spying on deeds! 🕵️📜
def log_action(username, action):
    if 'action_log' not in st.session_state:
        st.session_state.action_log = {}
    user_log = st.session_state.action_log.setdefault(username, {})
    current_time = time.time()
    user_log = {k: v for k, v in user_log.items() if current_time - v < 10}
    st.session_state.action_log[username] = user_log
    if action not in user_log:
        central = pytz.timezone('US/Central')
        with open(HISTORY_FILE, 'a') as f:
            f.write(f"[{datetime.now(central).strftime('%Y-%m-%d %H:%M:%S')}] {username}: {action}\n")
        user_log[action] = current_time

# Clean text - strip the fancy stuff! 🧹📝
def clean_text_for_tts(text):
    cleaned = re.sub(r'[#*!\[\]]+', '', text)
    cleaned = ' '.join(cleaned.split())
    return cleaned[:200] if cleaned else "No text to speak"

# Audio Processor Class from your code
class AudioProcessor:
    def __init__(self):
        self.cache_dir = "audio_cache"
        os.makedirs(self.cache_dir, exist_ok=True)
        self.metadata = self._load_metadata()

    def _load_metadata(self):
        metadata_file = os.path.join(self.cache_dir, "metadata.json")
        return json.load(open(metadata_file)) if os.path.exists(metadata_file) else {}

    def _save_metadata(self):
        metadata_file = os.path.join(self.cache_dir, "metadata.json")
        with open(metadata_file, 'w') as f:
            json.dump(self.metadata, f)

    async def create_audio(self, text, voice='en-US-AriaNeural', filename=None):
        cache_key = hashlib.md5(f"{text}:{voice}".encode()).hexdigest()
        cache_path = filename or os.path.join(self.cache_dir, f"{cache_key}.mp3")

        if cache_key in self.metadata and os.path.exists(cache_path):
            return open(cache_path, 'rb').read()

        # Clean text for speech
        text = text.replace("\n", " ").replace("</s>", " ").strip()
        if not text:
            return None

        # Generate audio with edge_tts
        communicate = edge_tts.Communicate(text, voice)
        await communicate.save(cache_path)

        # Update metadata
        self.metadata[cache_key] = {
            'timestamp': datetime.now().isoformat(),
            'text_length': len(text),
            'voice': voice
        }
        self._save_metadata()

        return open(cache_path, 'rb').read()

# Chat saver - words locked tight! 💬🔒
async def save_chat_entry(username, message, is_markdown=False, quote_line=None):
    await asyncio.to_thread(log_action, username, "💬🔒 - Chat saver - words locked tight!")
    central = pytz.timezone('US/Central')
    timestamp = datetime.now(central).strftime("%Y-%m-%d %H:%M:%S")
    user_history_file = f"{username}_history.md"
    voice = st.session_state.voice if username == st.session_state.username else FUN_USERNAMES.get(username, "en-US-AriaNeural")
    indent = "  " if quote_line else ""  # Nesting for replies
    if is_markdown:
        entry = f"{indent}[{timestamp}] {username}:\n{indent}```markdown\n{indent}{message}\n{indent}```"
    else:
        entry = f"{indent}[{timestamp}] {username}: {message}"
    if quote_line:
        entry = f"{indent}> {quote_line}\n{entry}"

    # Save to global chat file
    await asyncio.to_thread(lambda: open(CHAT_FILE, 'a').write(f"{entry}\n"))

    # Save to user-specific history file
    if not os.path.exists(user_history_file):
        with open(user_history_file, 'w') as f:
            f.write(f"# Chat History for {username} (Voice: {voice})\n\n")
    with open(user_history_file, 'a') as f:
        f.write(f"{entry}\n")

    cleaned_message = clean_text_for_tts(message)
    audio_processor = AudioProcessor()
    audio_filename = f"{format_timestamp_prefix(username)}-{hashlib.md5(cleaned_message.encode()).hexdigest()[:8]}.mp3"
    audio_data = await audio_processor.create_audio(cleaned_message, voice, audio_filename)
    if audio_data:
        with open(HISTORY_FILE, 'a') as f:
            f.write(f"[{timestamp}] {username} ({voice}): Audio generated - {audio_filename}\n")
        with open(user_history_file, 'a') as f:
            f.write(f"{indent}[{timestamp}] Audio: {audio_filename}\n")
        
        # Embed audio and image in global chat if applicable
        if message.startswith("Pasted image:") or message.startswith("Uploaded media:") or message.startswith("Uploaded PDF:"):
            with open(CHAT_FILE, 'a') as f:
                f.write(f"{indent}[{timestamp}] Audio: {audio_filename}\n")
                file_path = message.split(": ")[1]
                if os.path.exists(file_path) and file_path.endswith(('.png', '.jpg', '.mp4', '.pdf')):
                    f.write(f"{indent}[{timestamp}] Media: ![Media]({file_path})\n")

    await broadcast_message(f"{username}|{message}", "chat")
    st.session_state.last_chat_update = time.time()
    return audio_filename

# Save chat history with image or PDF
async def save_chat_history_with_image(username, image_path):
    central = pytz.timezone('US/Central')
    timestamp = datetime.now(central).strftime("%Y-%m-%d_%H-%M-%S")
    user_history_file = f"{username}_history.md"
    chat_content = await load_chat()
    voice = st.session_state.voice if username == st.session_state.username else FUN_USERNAMES.get(username, "en-US-AriaNeural")
    if not os.path.exists(user_history_file):
        with open(user_history_file, 'w') as f:
            f.write(f"# Chat History for {username} (Voice: {voice})\n\n")
    with open(user_history_file, 'a') as f:
        f.write(f"[{timestamp}] {username} (Voice: {voice}) Shared Media: {os.path.basename(image_path)}\n")
        f.write(f"```markdown\n{chat_content}\n```\n")

# Chat loader - history unleashed! 📜🚀
async def load_chat():
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "📜🚀 - Chat loader - history unleashed!")
    if not os.path.exists(CHAT_FILE):
        await asyncio.to_thread(lambda: open(CHAT_FILE, 'a').write(f"# {START_ROOM} Chat\n\nWelcome to the cosmic hub - start chatting! 🎤\n"))
    with open(CHAT_FILE, 'r') as f:
        content = await asyncio.to_thread(f.read)
    return content

# User lister - who’s in the gang! 👥🎉
async def get_user_list(chat_content):
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "👥🎉 - User lister - who’s in the gang!")
    users = set()
    for line in chat_content.split('\n'):
        if line.strip() and ': ' in line:
            user = line.split(': ')[1].split(' ')[0]
            users.add(user)
    return sorted(list(users))

# Join checker - been here before? 🚪🔍
async def has_joined_before(client_id, chat_content):
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "🚪🔍 - Join checker - been here before?")
    return any(f"Client-{client_id}" in line for line in chat_content.split('\n'))

# Suggestion maker - old quips resurface! 💡📝
async def get_message_suggestions(chat_content, prefix):
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "💡📝 - Suggestion maker - old quips resurface!")
    lines = chat_content.split('\n')
    messages = [line.split(': ', 1)[1] for line in lines if ': ' in line and line.strip()]
    return [msg for msg in messages if msg.lower().startswith(prefix.lower())][:5]

# Vote saver - cheers recorded! 👍📊
async def save_vote(file, item, user_hash, username, comment=""):
    await asyncio.to_thread(log_action, username, "👍📊 - Vote saver - cheers recorded!")
    central = pytz.timezone('US/Central')
    timestamp = datetime.now(central).strftime("%Y-%m-%d %H:%M:%S")
    entry = f"[{timestamp}] {user_hash} voted for {item}"
    await asyncio.to_thread(lambda: open(file, 'a').write(f"{entry}\n"))
    await asyncio.to_thread(lambda: open(HISTORY_FILE, "a").write(f"- {timestamp} - User {user_hash} voted for {item}\n"))
    chat_message = f"{username} upvoted: \"{item}\""
    if comment:
        chat_message += f" - {comment}"
    await save_chat_entry(username, chat_message)

# Vote counter - tallying the love! 🏆📈
async def load_votes(file):
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "🏆📈 - Vote counter - tallying the love!")
    if not os.path.exists(file):
        await asyncio.to_thread(lambda: open(file, 'w').write("# Vote Tally\n\nNo votes yet - get clicking! 🖱️\n"))
    with open(file, 'r') as f:
        content = await asyncio.to_thread(f.read)
        lines = content.strip().split('\n')[2:]
    votes = {}
    user_votes = set()
    for line in lines:
        if line.strip() and 'voted for' in line:
            user_hash = line.split('] ')[1].split(' voted for ')[0]
            item = line.split('voted for ')[1]
            vote_key = f"{user_hash}-{item}"
            if vote_key not in user_votes:
                votes[item] = votes.get(item, 0) + 1
                user_votes.add(vote_key)
    return votes

# Hash generator - secret codes ahoy! 🔑🕵️
async def generate_user_hash():
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "🔑🕵️ - Hash generator - secret codes ahoy!")
    if 'user_hash' not in st.session_state:
        st.session_state.user_hash = hashlib.md5(str(random.getrandbits(128)).encode()).hexdigest()[:8]
    return st.session_state.user_hash

# Audio maker - voices come alive! 🎶🌟
async def async_edge_tts_generate(text, voice, rate=0, pitch=0, file_format="mp3"):
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "🎶🌟 - Audio maker - voices come alive!")
    timestamp = format_timestamp_prefix(username)
    filename = f"{timestamp}-{hashlib.md5(text.encode()).hexdigest()[:8]}.{file_format}"
    filepath = filename  # Top-level file
    communicate = edge_tts.Communicate(text, voice, rate=f"{rate:+d}%", pitch=f"{pitch:+d}Hz")
    try:
        await communicate.save(filepath)
        return filepath if os.path.exists(filepath) else None
    except edge_tts.exceptions.NoAudioReceived:
        with open(HISTORY_FILE, 'a') as f:
            central = pytz.timezone('US/Central')
            f.write(f"[{datetime.now(central).strftime('%Y-%m-%d %H:%M:%S')}] {username}: Audio failed - No audio received for '{text}'\n")
        return None

# Audio player - tunes blast off! 🔊🚀
def play_and_download_audio(file_path):
    if file_path and os.path.exists(file_path):
        st.audio(file_path)
        if file_path not in st.session_state.base64_cache:
            with open(file_path, "rb") as f:
                b64 = base64.b64encode(f.read()).decode()
            st.session_state.base64_cache[file_path] = b64
        b64 = st.session_state.base64_cache[file_path]
        dl_link = f'<a href="data:audio/mpeg;base64,{b64}" download="{os.path.basename(file_path)}">🎵 Download {os.path.basename(file_path)}</a>'
        st.markdown(dl_link, unsafe_allow_html=True)

# Image saver - pics preserved with naming! 📸💾
async def save_pasted_image(image, username):
    await asyncio.to_thread(log_action, username, "📸💾 - Image saver - pics preserved!")
    img_hash = compute_image_hash(image)
    if img_hash in st.session_state.image_hashes:
        return None
    timestamp = format_timestamp_prefix(username)
    filename = f"{timestamp}-{img_hash}.png"
    filepath = filename  # Top-level file
    await asyncio.to_thread(image.save, filepath, "PNG")
    st.session_state.image_hashes.add(img_hash)
    await save_chat_history_with_image(username, filepath)
    return filepath

# PDF saver and audio generator
async def save_pdf_and_generate_audio(pdf_file, username, max_pages=10):
    await asyncio.to_thread(log_action, username, "📜🎶 - PDF saver and audio generator!")
    timestamp = format_timestamp_prefix(username)
    file_hash = hashlib.md5(pdf_file.getbuffer()).hexdigest()[:8]
    pdf_filename = f"{timestamp}-{file_hash}.pdf"
    with open(pdf_filename, 'wb') as f:
        f.write(pdf_file.getbuffer())

    reader = PdfReader(pdf_filename)
    total_pages = min(len(reader.pages), max_pages)
    texts = []
    audio_files = []

    audio_processor = AudioProcessor()
    voice = st.session_state.voice if username == st.session_state.username else FUN_USERNAMES.get(username, "en-US-AriaNeural")

    for i in range(total_pages):
        text = reader.pages[i].extract_text()
        texts.append(text)
        audio_filename = f"{timestamp}-page{i+1}-{file_hash}.mp3"
        audio_data = await audio_processor.create_audio(text, voice, audio_filename)
        if audio_data:
            audio_files.append(audio_filename)

    return pdf_filename, texts, audio_files

# Video renderer - movies roll with autoplay! 🎥🎬
def get_video_html(video_path, width="100%"):
    video_url = f"data:video/mp4;base64,{base64.b64encode(open(video_path, 'rb').read()).decode()}"
    return f'''
    <video width="{width}" controls autoplay muted loop>
        <source src="{video_url}" type="video/mp4">
        Your browser does not support the video tag.
    </video>
    '''

# Audio renderer - sounds soar! 🎶✈️
async def get_audio_html(audio_path, width="100%"):
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "🎶✈️ - Audio renderer - sounds soar!")
    audio_url = f"data:audio/mpeg;base64,{base64.b64encode(await asyncio.to_thread(open, audio_path, 'rb').read()).decode()}"
    return f'<audio controls style="width: {width};"><source src="{audio_url}" type="audio/mpeg">Your browser does not support the audio element.</audio>'

# Websocket handler - chat links up! 🌐🔗
async def websocket_handler(websocket, path):
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "🌐🔗 - Websocket handler - chat links up!")
    try:
        client_id = str(uuid.uuid4())
        room_id = "chat"
        st.session_state.active_connections.setdefault(room_id, {})[client_id] = websocket
        chat_content = await load_chat()
        username = st.session_state.get('username', random.choice(list(FUN_USERNAMES.keys())))
        if not await has_joined_before(client_id, chat_content):
            await save_chat_entry(f"Client-{client_id}", f"{username} has joined {START_ROOM}!")
        async for message in websocket:
            parts = message.split('|', 1)
            if len(parts) == 2:
                username, content = parts
                await save_chat_entry(username, content)
    except websockets.ConnectionClosed:
        pass
    finally:
        if room_id in st.session_state.active_connections and client_id in st.session_state.active_connections[room_id]:
            del st.session_state.active_connections[room_id][client_id]

# Message broadcaster - words fly far! 📢✈️
async def broadcast_message(message, room_id):
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "📢✈️ - Message broadcaster - words fly far!")
    if room_id in st.session_state.active_connections:
        disconnected = []
        for client_id, ws in st.session_state.active_connections[room_id].items():
            try:
                await ws.send(message)
            except websockets.ConnectionClosed:
                disconnected.append(client_id)
        for client_id in disconnected:
            del st.session_state.active_connections[room_id][client_id]

# Server starter - web spins up! 🖥️🌀
async def run_websocket_server():
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "🖥️🌀 - Server starter - web spins up!")
    if not st.session_state.server_running:
        server = await websockets.serve(websocket_handler, '0.0.0.0', 8765)
        st.session_state.server_running = True
        await server.wait_closed()

# Dummy AI lookup function (replace with actual implementation)
async def perform_ai_lookup(query, vocal_summary=True, extended_refs=False, titles_summary=True, full_audio=False, useArxiv=True, useArxivAudio=False):
    username = st.session_state.get('username', 'System 🌟')
    result = f"AI Lookup Result for '{query}' (Arxiv: {useArxiv}, Audio: {useArxivAudio})"
    await save_chat_entry(username, result)
    if useArxivAudio:
        audio_file = await async_edge_tts_generate(result, st.session_state.voice)
        if audio_file:
            st.audio(audio_file)

# Delete all user files function
def delete_user_files():
    protected_files = {'app.py', 'requirements.txt', 'README.md', CHAT_FILE, QUOTE_VOTES_FILE, MEDIA_VOTES_FILE, HISTORY_FILE, STATE_FILE}
    deleted_files = []
    for file in os.listdir('.'):
        if file not in protected_files and not file.endswith('_history.md'):
            try:
                os.remove(file)
                deleted_files.append(file)
            except Exception as e:
                st.error(f"Failed to delete {file}: {e}")
    st.session_state.image_hashes.clear()
    st.session_state.audio_cache.clear()
    st.session_state.base64_cache.clear()
    st.session_state.displayed_chat_lines.clear()
    return deleted_files

# Query parameter checker - parse q for username
def check_query_params():
    query_params = st.query_params if hasattr(st, 'query_params') else st.experimental_get_query_params()
    q_value = query_params.get("q", [None])[0]
    if q_value and q_value in FUN_USERNAMES:
        st.session_state.username = q_value
        st.session_state.voice = FUN_USERNAMES[q_value]
    elif q_value:
        st.session_state.user_id = q_value  # Use as user_id if not a valid username
    return q_value

# Main execution - let’s roll! 🎲🚀
def main():
    NODE_NAME, port = get_node_name()

    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)

    async def async_interface():
        # Generate user ID and hash if not set
        if not st.session_state.user_id:
            st.session_state.user_id = str(uuid.uuid4())
            st.session_state.user_hash = await generate_user_hash()
        if 'username' not in st.session_state:
            q_value = check_query_params()
            if not q_value or q_value not in FUN_USERNAMES:
                chat_content = await load_chat()
                available_names = [name for name in FUN_USERNAMES if not any(f"{name} has joined" in line for line in chat_content.split('\n'))]
                st.session_state.username = random.choice(available_names) if available_names else random.choice(list(FUN_USERNAMES.keys()))
            st.session_state.voice = FUN_USERNAMES[st.session_state.username]
            st.markdown(f"**🎙️ Voice Selected**: {st.session_state.voice} 🗣️ for {st.session_state.username}")

        # Check existing history file for content
        user_history_file = f"{st.session_state.username}_history.md"
        if os.path.exists(user_history_file):
            with open(user_history_file, 'r') as f:
                st.session_state.displayed_chat_lines = f.read().split('\n')

        user_url = f"/q={st.session_state.username}"
        st.write(f"Your unique URL path: [{user_url}]({user_url})")

        st.title(f"🤖🧠MMO {st.session_state.username}📝🔬")
        st.markdown(f"Welcome to {START_ROOM} - chat, vote, upload, paste images, and enjoy quoting! 🎉 User ID: {st.session_state.user_id}")

        if not st.session_state.server_task:
            st.session_state.server_task = loop.create_task(run_websocket_server())

        # Unified Chat History at Top
        st.subheader(f"{START_ROOM} Chat History 💬")
        chat_content = await load_chat()
        chat_lines = [line for line in chat_content.split('\n') if line.strip() and not line.startswith('#')]
        if chat_lines:
            col1, col2 = st.columns([2, 1])
            with col1:
                st.write("### Text & Audio Chat")
                for i, line in enumerate(reversed(chat_lines)):  # Descending order
                    col_text, col_audio = st.columns([3, 1])
                    with col_text:
                        if "```markdown" in line:
                            markdown_content = re.search(r'```markdown\n(.*?)(?=\n\s*\[|$)', line, re.DOTALL)
                            if markdown_content:
                                st.markdown(markdown_content.group(1))
                            else:
                                st.markdown(line)
                        else:
                            st.markdown(line)
                        if "Media:" in line:
                            file_path = line.split("Media: ")[-1].strip('![]()')
                            if os.path.exists(file_path):
                                if file_path.endswith(('.png', '.jpg')):
                                    st.image(file_path, use_container_width=True)
                                elif file_path.endswith('.mp4'):
                                    st.markdown(get_video_html(file_path), unsafe_allow_html=True)
                                elif file_path.endswith('.pdf'):
                                    st.write(f"PDF: {os.path.basename(file_path)}")
                    with col_audio:
                        username = line.split(': ')[1].split(' ')[0] if ': ' in line else "Unknown"
                        cache_key = f"{line}_{FUN_USERNAMES.get(username, 'en-US-AriaNeural')}"
                        if cache_key not in st.session_state.audio_cache and "Audio:" in line:
                            audio_ref = line.split("Audio: ")[-1].strip()
                            if os.path.exists(audio_ref):
                                st.session_state.audio_cache[cache_key] = audio_ref
                            else:
                                cleaned_text = clean_text_for_tts(line.split(': ', 1)[1].split("Audio:")[0])
                                voice = st.session_state.voice if username == st.session_state.username else FUN_USERNAMES.get(username, "en-US-AriaNeural")
                                audio_file = await async_edge_tts_generate(cleaned_text, voice)
                                st.session_state.audio_cache[cache_key] = audio_file
                        audio_file = st.session_state.audio_cache.get(cache_key)
                        if audio_file:
                            play_and_download_audio(audio_file)

        if st.session_state.quote_line:
            st.markdown(f"### Quoting: {st.session_state.quote_line}")
            quote_response = st.text_area("Add your response", key="quote_response", value=st.session_state.message_text)
            paste_result_quote = paste_image_button("📋 Paste Image or Text with Quote", key="paste_button_quote")
            if paste_result_quote.image_data is not None:
                if isinstance(paste_result_quote.image_data, str):
                    st.session_state.message_text = paste_result_quote.image_data
                    st.text_area("Add your response", key="quote_response", value=st.session_state.message_text)
                else:
                    st.image(paste_result_quote.image_data, caption="Received Image for Quote")
                    filename = await save_pasted_image(paste_result_quote.image_data, st.session_state.username)
                    if filename:
                        st.session_state.pasted_image_data = filename
                        await save_chat_entry(st.session_state.username, f"Pasted image: {filename}", quote_line=st.session_state.quote_line)
            if st.button("Send Quote 🚀", key="send_quote"):
                markdown_response = f"### Quote Response\n- **Original**: {st.session_state.quote_line}\n- **{st.session_state.username} Replies**: {quote_response}"
                if st.session_state.pasted_image_data:
                    markdown_response += f"\n- **Image**: ![Pasted Image]({st.session_state.pasted_image_data})"
                    await save_chat_entry(st.session_state.username, f"Pasted image: {st.session_state.pasted_image_data}", quote_line=st.session_state.quote_line)
                    st.session_state.pasted_image_data = None
                await save_chat_entry(st.session_state.username, markdown_response, is_markdown=True, quote_line=st.session_state.quote_line)
                st.session_state.quote_line = None
                st.session_state.message_text = ''
                st.rerun()

        current_selection = st.session_state.username if st.session_state.username in FUN_USERNAMES else ""
        new_username = st.selectbox("Change Name and Voice", [""] + list(FUN_USERNAMES.keys()), index=(list(FUN_USERNAMES.keys()).index(current_selection) + 1 if current_selection else 0), format_func=lambda x: f"{x} ({FUN_USERNAMES.get(x, 'No Voice')})" if x else "Select a name")
        if new_username and new_username != st.session_state.username:
            await save_chat_entry("System 🌟", f"{st.session_state.username} changed name to {new_username}")
            st.session_state.username = new_username
            st.session_state.voice = FUN_USERNAMES[new_username]
            st.markdown(f"**🎙️ Voice Changed**: {st.session_state.voice} 🗣️ for {st.session_state.username}")
            st.rerun()

        # Message input with Send button on the right
        col_input, col_send = st.columns([5, 1])
        with col_input:
            message = st.text_input(f"Message as {st.session_state.username} (Voice: {st.session_state.voice})", key="message_input", value=st.session_state.message_text)
        with col_send:
            if st.button("Send 🚀", key="send_button"):
                if message.strip():
                    audio_file = await save_chat_entry(st.session_state.username, message, is_markdown=True)
                    if audio_file:
                        st.session_state.audio_cache[f"{message}_{FUN_USERNAMES[st.session_state.username]}"] = audio_file
                        st.audio(audio_file)  # Immediate preview
                if st.session_state.pasted_image_data:
                    await save_chat_entry(st.session_state.username, f"Pasted image: {st.session_state.pasted_image_data}")
                    st.session_state.pasted_image_data = None
                st.session_state.message_text = ''
                st.rerun()

        paste_result_msg = paste_image_button("📋 Paste Image or Text with Message", key="paste_button_msg")
        if paste_result_msg.image_data is not None:
            if isinstance(paste_result_msg.image_data, str):
                st.session_state.message_text = paste_result_msg.image_data
                st.text_input(f"Message as {st.session_state.username} (Voice: {st.session_state.voice})", key="message_input_paste", value=st.session_state.message_text)
            else:
                st.image(paste_result_msg.image_data, caption="Received Image for Message")
                filename = await save_pasted_image(paste_result_msg.image_data, st.session_state.username)
                if filename:
                    await save_chat_entry(st.session_state.username, f"Pasted image: {filename}")
                    st.session_state.pasted_image_data = None

        tab_main = st.radio("Action:", ["📸 Media", "🔍 ArXiv", "📝 Editor"], horizontal=True)
        useArxiv = st.checkbox("Search Arxiv for Research Paper Answers", value=True)
        useArxivAudio = st.checkbox("Generate Audio File for Research Paper Answers", value=False)

        st.subheader("Upload Media 🎨🎶📜🎥")
        uploaded_file = st.file_uploader("Upload Media", type=['png', 'jpg', 'mp4', 'mp3', 'wav', 'pdf'])
        if uploaded_file:
            timestamp = format_timestamp_prefix(st.session_state.username)
            username = st.session_state.username
            ext = uploaded_file.name.split('.')[-1]
            file_hash = hashlib.md5(uploaded_file.getbuffer()).hexdigest()[:8]
            if file_hash not in st.session_state.image_hashes:
                filename = f"{timestamp}-{file_hash}.{ext}"
                file_path = filename  # Top-level file
                await asyncio.to_thread(lambda: open(file_path, 'wb').write(uploaded_file.getbuffer()))
                st.success(f"Uploaded {filename}")
                if ext == 'pdf':
                    pdf_filename, texts, audio_files = await save_pdf_and_generate_audio(uploaded_file, username)
                    await save_chat_entry(username, f"Uploaded PDF: {pdf_filename}")
                    for i, (text, audio_file) in enumerate(zip(texts, audio_files)):
                        with open(CHAT_FILE, 'a') as f:
                            f.write(f"  [{timestamp}] Page {i+1} Audio: {audio_file}\n")
                else:
                    await save_chat_entry(username, f"Uploaded media: {file_path}")
                await save_chat_history_with_image(username, file_path)
                st.session_state.image_hashes.add(file_hash)
                if file_path.endswith('.mp4'):
                    st.session_state.media_notifications.append(file_path)

        # Big Red Delete Button
        st.subheader("🛑 Danger Zone")
        if st.button("Try Not To Delete It All On Your First Day", key="delete_all", help="Deletes all user-added files!", type="primary", use_container_width=True):
            deleted_files = delete_user_files()
            if deleted_files:
                st.markdown("### 🗑️ Deleted Files:\n" + "\n".join([f"- `{file}`" for file in deleted_files]))
            else:
                st.markdown("### 🗑️ Nothing to Delete!")
            st.rerun()

        st.subheader("Refresh ⏳")
        refresh_rate = st.slider("Refresh Rate", 1, 300, st.session_state.refresh_rate)
        st.session_state.refresh_rate = refresh_rate
        timer_placeholder = st.empty()
        for i in range(st.session_state.refresh_rate, -1, -1):
            font_name, font_func = random.choice(UNICODE_FONTS)
            countdown_str = "".join(UNICODE_DIGITS[int(d)] for d in str(i)) if i < 10 else font_func(str(i))
            timer_placeholder.markdown(f"<p class='timer'>⏳ {font_func('Refresh in:')} {countdown_str}</p>", unsafe_allow_html=True)
            time.sleep(1)
        st.rerun()

        # Gallery with Adjustable Tiles
        st.subheader("Media Gallery 🎨🎶📜🎥")
        gallery_columns = st.slider("Number of Gallery Tiles", 1, 20, st.session_state.gallery_columns)
        st.session_state.gallery_columns = gallery_columns
        media_files = glob.glob("*.png") + glob.glob("*.jpg") + glob.glob("*.mp4") + glob.glob("*.pdf")
        if media_files:
            media_votes = await load_votes(MEDIA_VOTES_FILE)
            seen_files = set()
            cols = st.columns(gallery_columns)
            col_idx = 0
            for media_file in sorted(media_files, key=os.path.getmtime, reverse=True):
                if media_file not in seen_files:
                    seen_files.add(media_file)
                    with cols[col_idx]:
                        filename = os.path.basename(media_file)
                        vote_count = media_votes.get(media_file, 0)
                        st.markdown(f"**{filename}**")
                        if media_file.endswith(('.png', '.jpg')):
                            st.image(media_file, use_container_width=True)
                        elif media_file.endswith('.mp4'):
                            st.markdown(get_video_html(media_file), unsafe_allow_html=True)
                        elif media_file.endswith('.pdf'):
                            st.write(f"PDF: {filename}")
                        if st.button(f"👍 {vote_count}", key=f"media_vote_{media_file}"):
                            await save_vote(MEDIA_VOTES_FILE, media_file, await generate_user_hash(), st.session_state.username)
                            st.rerun()
                    col_idx = (col_idx + 1) % gallery_columns

        # Full Log at End
        st.subheader("Full Chat Log 📜")
        with open(HISTORY_FILE, 'r') as f:
            history_content = f.read()
        st.markdown(history_content)

    loop.run_until_complete(async_interface())

if __name__ == "__main__":
    main()