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
from audio_recorder_streamlit import audio_recorder
import nest_asyncio
import re
from streamlit_paste_button import paste_image_button
import pytz
import shutil
import anthropic
import openai
from PyPDF2 import PdfReader
import threading
import json
import zipfile
from gradio_client import Client
from dotenv import load_dotenv
from streamlit_marquee import streamlit_marquee

# Patch for nested async
nest_asyncio.apply()

# Static config
icons = '🤖🧠🔬📝'
START_ROOM = "Sector 🌌"

# Page setup
st.set_page_config(
    page_title="🤖🧠MMO Chat & Research Brain📝🔬",
    page_icon=icons,
    layout="wide",
    initial_sidebar_state="auto"
)

# Funky usernames with 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"
}

# Directories
CHAT_DIR = "chat_logs"
VOTE_DIR = "vote_logs"
AUDIO_DIR = "audio_logs"
HISTORY_DIR = "history_logs"
MEDIA_DIR = "media_files"
os.makedirs(CHAT_DIR, exist_ok=True)
os.makedirs(VOTE_DIR, exist_ok=True)
os.makedirs(AUDIO_DIR, exist_ok=True)
os.makedirs(HISTORY_DIR, exist_ok=True)
os.makedirs(MEDIA_DIR, exist_ok=True)

CHAT_FILE = os.path.join(CHAT_DIR, "global_chat.md")
QUOTE_VOTES_FILE = os.path.join(VOTE_DIR, "quote_votes.md")
MEDIA_VOTES_FILE = os.path.join(VOTE_DIR, "media_votes.md")
HISTORY_FILE = os.path.join(HISTORY_DIR, "chat_history.md")

# Unicode digits
UNICODE_DIGITS = {i: f"{i}\uFE0F⃣" for i in range(10)}

# Unicode fonts
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)),
    # Add other font styles similarly...
]

# Global state
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 'transcript_history' not in st.session_state:
    st.session_state.transcript_history = []
if 'last_transcript' not in st.session_state:
    st.session_state.last_transcript = ""
if 'image_hashes' not in st.session_state:
    st.session_state.image_hashes = set()
if 'tts_voice' not in st.session_state:
    st.session_state.tts_voice = "en-US-AriaNeural"
if 'chat_history' not in st.session_state:
    st.session_state.chat_history = []

# API Keys
load_dotenv()
anthropic_key = os.getenv('ANTHROPIC_API_KEY', "")
openai_api_key = os.getenv('OPENAI_API_KEY', "")
if 'ANTHROPIC_API_KEY' in st.secrets:
    anthropic_key = st.secrets['ANTHROPIC_API_KEY']
if 'OPENAI_API_KEY' in st.secrets:
    openai_api_key = st.secrets['OPENAI_API_KEY']
openai_client = openai.OpenAI(api_key=openai_api_key)

# Timestamp formatting
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}"

# Image hash computation
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
def get_node_name():
    parser = argparse.ArgumentParser(description='Start a chat node')
    parser.add_argument('--node-name', type=str, default=None)
    parser.add_argument('--port', type=int, default=8501)
    args = parser.parse_args()
    return args.node_name or f"node-{uuid.uuid4().hex[:8]}", args.port

# Action logger
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

# Text cleaning for TTS
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"

# Chat saver
async def save_chat_entry(username, message, is_markdown=False):
    await asyncio.to_thread(log_action, username, "💬🔒 - Chat saver")
    central = pytz.timezone('US/Central')
    timestamp = datetime.now(central).strftime("%Y-%m-%d %H:%M:%S")
    if is_markdown:
        entry = f"[{timestamp}] {username}:\n```markdown\n{message}\n```"
    else:
        entry = f"[{timestamp}] {username}: {message}"
    await asyncio.to_thread(lambda: open(CHAT_FILE, 'a').write(f"{entry}\n"))
    voice = FUN_USERNAMES.get(username, "en-US-AriaNeural")
    cleaned_message = clean_text_for_tts(message)
    audio_file = await async_edge_tts_generate(cleaned_message, voice)
    if audio_file:
        with open(HISTORY_FILE, 'a') as f:
            f.write(f"[{timestamp}] {username}: Audio generated - {audio_file}\n")
    await broadcast_message(f"{username}|{message}", "chat")
    st.session_state.last_chat_update = time.time()
    return audio_file

# Chat loader
async def load_chat():
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "📜🚀 - Chat loader")
    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! 🎤\n"))
    with open(CHAT_FILE, 'r') as f:
        content = await asyncio.to_thread(f.read)
    return content

# Audio generator
async def async_edge_tts_generate(text, voice, rate=0, pitch=0, file_format="mp3"):
    await asyncio.to_thread(log_action, st.session_state.get('username', 'System 🌟'), "🎶🌟 - Audio maker")
    timestamp = format_timestamp_prefix(st.session_state.get('username', 'System 🌟'))
    filename = f"{timestamp}.{file_format}"
    filepath = os.path.join(AUDIO_DIR, filename)
    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')}] Audio failed for '{text}'\n")
        return None

# Audio player
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)

# Websocket handler
async def websocket_handler(websocket, path):
    username = st.session_state.get('username', 'System 🌟')
    await asyncio.to_thread(log_action, username, "🌐🔗 - Websocket handler")
    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 any(f"Client-{client_id}" in line for line in chat_content.split('\n')):
            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
async def broadcast_message(message, room_id):
    await asyncio.to_thread(log_action, st.session_state.get('username', 'System 🌟'), "📢✈️ - Message broadcaster")
    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
async def run_websocket_server():
    await asyncio.to_thread(log_action, st.session_state.get('username', 'System 🌟'), "🖥️🌀 - Server starter")
    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()

# PDF to Audio Processor
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'):
        cache_key = hashlib.md5(f"{text}:{voice}".encode()).hexdigest()
        cache_path = 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()
        text = text.replace("\n", " ").replace("</s>", " ").strip()
        if not text:
            return None
        communicate = edge_tts.Communicate(text, voice)
        await communicate.save(cache_path)
        self.metadata[cache_key] = {
            'timestamp': datetime.now().isoformat(),
            'text_length': len(text),
            'voice': voice
        }
        self._save_metadata()
        return open(cache_path, 'rb').read()

def get_download_link(bin_data, filename, size_mb=None):
    b64 = base64.b64encode(bin_data).decode()
    size_str = f"({size_mb:.1f} MB)" if size_mb else ""
    return f'<a href="data:audio/mpeg;base64,{b64}" download="{filename}">📥 {filename} {size_str}</a>'

def process_pdf(pdf_file, max_pages, voice, audio_processor):
    reader = PdfReader(pdf_file)
    total_pages = min(len(reader.pages), max_pages)
    texts, audios = [], {}
    async def process_page(i, text):
        audio_data = await audio_processor.create_audio(text, voice)
        audios[i] = audio_data
    for i in range(total_pages):
        text = reader.pages[i].extract_text()
        texts.append(text)
        threading.Thread(target=lambda: asyncio.run(process_page(i, text))).start()
    return texts, audios, total_pages

# AI Lookup
def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, titles_summary=True, full_audio=False, useArxiv=True, useArxivAudio=False):
    client = anthropic.Anthropic(api_key=anthropic_key)
    response = client.messages.create(
        model="claude-3-sonnet-20240229",
        max_tokens=1000,
        messages=[{"role": "user", "content": q}]
    )
    result = response.content[0].text
    st.markdown("### Claude's reply 🧠:")
    st.markdown(result)
    md_file = create_file(q, result)
    audio_file = speak_with_edge_tts(result, st.session_state.tts_voice)
    play_and_download_audio(audio_file)
    if useArxiv:
        q += result
        gradio_client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
        refs = gradio_client.predict(q, 10, "Semantic Search", "mistralai/Mixtral-8x7B-Instruct-v0.1", api_name="/update_with_rag_md")[0]
        result = f"🔎 {q}\n\n{refs}"
        md_file, audio_file = save_qa_with_audio(q, result)
        play_and_download_audio(audio_file)
        papers = parse_arxiv_refs(refs)
        if papers and useArxivAudio:
            asyncio.run(create_paper_audio_files(papers, q))
        return result, papers
    return result, []

def create_file(prompt, response, file_type="md"):
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"{timestamp}_{clean_text_for_filename(prompt[:40] + ' ' + response[:40])}.{file_type}"
    with open(filename, 'w', encoding='utf-8') as f:
        f.write(prompt + "\n\n" + response)
    return filename

def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0, file_format="mp3"):
    result = asyncio.run(async_edge_tts_generate(text, voice, rate, pitch, file_format))
    return result

def save_qa_with_audio(question, answer, voice=None):
    voice = voice or st.session_state.tts_voice
    md_file = create_file(question, answer, "md")
    audio_file = speak_with_edge_tts(f"{question}\n\nAnswer: {answer}", voice)
    return md_file, audio_file

def clean_text_for_filename(text):
    text = text.lower()
    text = re.sub(r'[^\w\s-]', '', text)
    return '_'.join(text.split())[:200]

def parse_arxiv_refs(ref_text):
    # Simplified parsing for brevity
    return [{"title": line.strip(), "url": "", "authors": "", "summary": "", "full_audio": None, "download_base64": ""} for line in ref_text.split('\n') if line.strip()]

async def create_paper_audio_files(papers, input_question):
    for paper in papers:
        audio_text = f"{paper['title']}"
        audio_file = await async_edge_tts_generate(audio_text, st.session_state.tts_voice)
        paper['full_audio'] = audio_file
        if audio_file:
            with open(audio_file, "rb") as f:
                b64 = base64.b64encode(f.read()).decode()
            paper['download_base64'] = f'<a href="data:audio/mpeg;base64,{b64}" download="{os.path.basename(audio_file)}">🎵 Download</a>'

# ASR Component HTML (Fixed Audio Chat)
ASR_HTML = """
<html>
<head>
    <title>Continuous Speech Demo</title>
    <style>
        body { font-family: sans-serif; padding: 20px; max-width: 800px; margin: 0 auto; }
        button { padding: 10px 20px; margin: 10px 5px; font-size: 16px; }
        #status { margin: 10px 0; padding: 10px; background: #e8f5e9; border-radius: 4px; }
        #output { white-space: pre-wrap; padding: 15px; background: #f5f5f5; border-radius: 4px; margin: 10px 0; min-height: 100px; max-height: 400px; overflow-y: auto; }
    </style>
</head>
<body>
    <div>
        <button id="start">Start Listening</button>
        <button id="stop" disabled>Stop Listening</button>
        <button id="clear">Clear Text</button>
    </div>
    <div id="status">Ready</div>
    <div id="output"></div>
    <script>
        if (!('webkitSpeechRecognition' in window)) {
            alert('Speech recognition not supported');
        } else {
            const recognition = new webkitSpeechRecognition();
            const startButton = document.getElementById('start');
            const stopButton = document.getElementById('stop');
            const clearButton = document.getElementById('clear');
            const status = document.getElementById('status');
            const output = document.getElementById('output');
            let fullTranscript = '';
            let lastUpdateTime = Date.now();

            recognition.continuous = true;
            recognition.interimResults = true;

            const startRecognition = () => {
                try {
                    recognition.start();
                    status.textContent = 'Listening...';
                    startButton.disabled = true;
                    stopButton.disabled = false;
                } catch (e) {
                    console.error(e);
                    status.textContent = 'Error: ' + e.message;
                }
            };

            window.addEventListener('load', () => setTimeout(startRecognition, 1000));

            startButton.onclick = startRecognition;

            stopButton.onclick = () => {
                recognition.stop();
                status.textContent = 'Stopped';
                startButton.disabled = false;
                stopButton.disabled = true;
            };

            clearButton.onclick = () => {
                fullTranscript = '';
                output.textContent = '';
                sendDataToPython({value: '', dataType: "json"});
            };

            recognition.onresult = (event) => {
                let interimTranscript = '';
                let finalTranscript = '';

                for (let i = event.resultIndex; i < event.results.length; i++) {
                    const transcript = event.results[i][0].transcript;
                    if (event.results[i].isFinal) {
                        finalTranscript += transcript + '\\n';
                    } else {
                        interimTranscript += transcript;
                    }
                }

                if (finalTranscript || (Date.now() - lastUpdateTime > 5000)) {
                    if (finalTranscript) fullTranscript += finalTranscript;
                    lastUpdateTime = Date.now();
                    output.textContent = fullTranscript + (interimTranscript ? '... ' + interimTranscript : '');
                    output.scrollTop = output.scrollHeight;
                    sendDataToPython({value: fullTranscript, dataType: "json"});
                }
            };

            recognition.onend = () => {
                if (!stopButton.disabled) {
                    try {
                        recognition.start();
                        console.log('Restarted recognition');
                    } catch (e) {
                        console.error('Failed to restart:', e);
                        status.textContent = 'Error restarting: ' + e.message;
                        startButton.disabled = false;
                        stopButton.disabled = true;
                    }
                }
            };

            recognition.onerror = (event) => {
                console.error('Recognition error:', event.error);
                status.textContent = 'Error: ' + event.error;
                if (event.error === 'not-allowed' || event.error === 'service-not-allowed') {
                    startButton.disabled = false;
                    stopButton.disabled = true;
                }
            };
        }

        function sendDataToPython(data) {
            window.parent.postMessage({
                isStreamlitMessage: true,
                type: "streamlit:setComponentValue",
                ...data
            }, "*");
        }

        window.addEventListener('load', () => {
            window.setTimeout(() => {
                window.parent.postMessage({
                    isStreamlitMessage: true,
                    type: "streamlit:setFrameHeight",
                    height: document.documentElement.clientHeight
                }, "*");
            }, 0);
        });
    </script>
</body>
</html>
"""

# Main execution
def main():
    NODE_NAME, port = get_node_name()
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)

    async def async_interface():
        if 'username' not in st.session_state:
            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.tts_voice = FUN_USERNAMES[st.session_state.username]
            st.markdown(f"**🎙️ Voice**: {st.session_state.tts_voice} 🗣️ for {st.session_state.username}")

        st.title(f"🤖🧠MMO Chat & Research for {st.session_state.username}📝🔬")
        st.markdown(f"Welcome to {START_ROOM} - chat, research, upload, and more! 🎉")

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

        # Tabs
        tab_main = st.radio("Action:", ["🎤 Chat & Voice", "📸 Media", "🔍 ArXiv", "📚 PDF to Audio"], horizontal=True)
        useArxiv = st.checkbox("Search Arxiv", value=True)
        useArxivAudio = st.checkbox("Generate Arxiv Audio", value=False)

        # Chat & Voice Tab
        if tab_main == "🎤 Chat & Voice":
            st.subheader(f"{START_ROOM} Chat 💬")
            chat_content = await load_chat()
            chat_lines = chat_content.split('\n')
            for i, line in enumerate(chat_lines):
                if line.strip() and ': ' in line:
                    st.markdown(line)
                    if st.button("📢 Speak", key=f"speak_{i}"):
                        audio_file = await async_edge_tts_generate(clean_text_for_tts(line.split(': ', 1)[1]), st.session_state.tts_voice)
                        play_and_download_audio(audio_file)

            message = st.text_input(f"Message as {st.session_state.username}", key="message_input")
            if st.button("Send 🚀") and message.strip():
                await save_chat_entry(st.session_state.username, message, is_markdown=True)
                st.rerun()

            st.subheader("🎤 Continuous Speech Input")
            asr_component = components.html(ASR_HTML, height=400)
            if asr_component and isinstance(asr_component, dict) and 'value' in asr_component:
                transcript = asr_component['value'].strip()
                if transcript and transcript != st.session_state.last_transcript:
                    await save_chat_entry(st.session_state.username, transcript, is_markdown=True)
                    st.session_state.last_transcript = transcript
                    st.rerun()

        # Media Tab with Galleries
        elif tab_main == "📸 Media":
            st.header("📸 Media Gallery")
            tabs = st.tabs(["🎵 Audio", "🖼 Images", "🎥 Video"])
            with tabs[0]:
                st.subheader("🎵 Audio Files")
                audio_files = glob.glob(f"{MEDIA_DIR}/*.mp3")
                for a in audio_files:
                    with st.expander(os.path.basename(a)):
                        play_and_download_audio(a)
            with tabs[1]:
                st.subheader("🖼 Images")
                imgs = glob.glob(f"{MEDIA_DIR}/*.png") + glob.glob(f"{MEDIA_DIR}/*.jpg")
                if imgs:
                    cols = st.columns(3)
                    for i, f in enumerate(imgs):
                        with cols[i % 3]:
                            st.image(f, use_container_width=True)
            with tabs[2]:
                st.subheader("🎥 Videos")
                vids = glob.glob(f"{MEDIA_DIR}/*.mp4")
                for v in vids:
                    with st.expander(os.path.basename(v)):
                        st.video(v)

            uploaded_file = st.file_uploader("Upload Media", type=['png', 'jpg', 'mp4', 'mp3'])
            if uploaded_file:
                timestamp = format_timestamp_prefix(st.session_state.username)
                ext = uploaded_file.name.split('.')[-1]
                file_hash = hashlib.md5(uploaded_file.getbuffer()).hexdigest()[:8]
                filename = f"{timestamp}-{file_hash}.{ext}"
                file_path = os.path.join(MEDIA_DIR, filename)
                with open(file_path, 'wb') as f:
                    f.write(uploaded_file.getbuffer())
                await save_chat_entry(st.session_state.username, f"Uploaded media: {file_path}")
                st.rerun()

        # ArXiv Tab
        elif tab_main == "🔍 ArXiv":
            st.subheader("🔍 Query ArXiv")
            q = st.text_input("🔍 Query:")
            if q and st.button("🔍 Run"):
                result, papers = perform_ai_lookup(q, useArxiv=useArxiv, useArxivAudio=useArxivAudio)
                for paper in papers:
                    with st.expander(paper['title']):
                        st.markdown(f"**Summary**: {paper['summary']}")
                        if paper['full_audio']:
                            play_and_download_audio(paper['full_audio'])

        # PDF to Audio Tab
        elif tab_main == "📚 PDF to Audio":
            st.subheader("📚 PDF to Audio Converter")
            audio_processor = AudioProcessor()
            uploaded_file = st.file_uploader("Choose a PDF file", "pdf")
            max_pages = st.slider('Pages to process', 1, 100, 10)
            if uploaded_file:
                with st.spinner('Processing PDF...'):
                    texts, audios, total_pages = process_pdf(uploaded_file, max_pages, st.session_state.tts_voice, audio_processor)
                    for i, text in enumerate(texts):
                        with st.expander(f"Page {i+1}"):
                            st.markdown(text)
                            while i not in audios:
                                time.sleep(0.1)
                            if audios[i]:
                                st.audio(audios[i], format='audio/mp3')
                                st.markdown(get_download_link(audios[i], f'page_{i+1}.mp3', len(audios[i]) / (1024 * 1024)), unsafe_allow_html=True)

        # Sidebar
        st.sidebar.subheader("Voice Settings")
        new_username = st.sidebar.selectbox("Change Name/Voice", list(FUN_USERNAMES.keys()), index=list(FUN_USERNAMES.keys()).index(st.session_state.username))
        if new_username != st.session_state.username:
            await save_chat_entry("System 🌟", f"{st.session_state.username} changed to {new_username}")
            st.session_state.username = new_username
            st.session_state.tts_voice = FUN_USERNAMES[new_username]
            st.rerun()

    loop.run_until_complete(async_interface())

if __name__ == "__main__":
    main()