import gradio as gr
import subprocess
import asyncio
import threading
from queue import Queue, Empty
import os
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes

# Env vars or hardcode your Telegram bot token here
BOT_TOKEN = os.environ.get("BOT_TOKEN", "7510817339:AAHFZoFzPkUO_-nAwfh9bjY_qHsWMprM2PI")
# Globals
bot_app = None  # Telegram Application instance
bot_thread = None
bot_running = False
log_queue = Queue()
telegram_cmd_logs = []

# -- Telegram Bot Handlers --

async def bash_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    cmd = ' '.join(context.args)
    if not cmd:
        await update.message.reply_text("Usage: /bash <command>")
        return

    log_queue.put(f"[Telegram] Received command: {cmd}")

    # Run command and collect output (limit max 4000 chars for Telegram)
    try:
        proc = await asyncio.create_subprocess_shell(
            cmd,
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.STDOUT,
        )
        stdout, _ = await proc.communicate()
        output = stdout.decode().strip()
        if len(output) > 4000:
            output = output[:4000] + "\n...[truncated]"
    except Exception as e:
        output = f"Error running command: {e}"

    await update.message.reply_text(f"$ {cmd}\n{output}")

    telegram_cmd_logs.append(f"$ {cmd}\n{output}")
    # Limit logs to last 50 commands
    if len(telegram_cmd_logs) > 50:
        telegram_cmd_logs.pop(0)

def start_bot():
    global bot_app, bot_running

    if bot_running:
        log_queue.put("[Bot] Already running.")
        return

    async def run_bot():
        global bot_app, bot_running
        bot_app = ApplicationBuilder().token(BOT_TOKEN).build()
        bot_app.add_handler(CommandHandler("bash", bash_command))
        bot_running = True
        log_queue.put("[Bot] Bot started.")
        await bot_app.run_polling()

    loop = asyncio.new_event_loop()

    def runner():
        asyncio.set_event_loop(loop)
        loop.run_until_complete(run_bot())

    global bot_thread
    bot_thread = threading.Thread(target=runner, daemon=True)
    bot_thread.start()

def stop_bot():
    global bot_app, bot_running
    if not bot_running:
        log_queue.put("[Bot] Bot is not running.")
        return

    async def shutdown():
        await bot_app.shutdown()
        await bot_app.stop()
        log_queue.put("[Bot] Bot stopped.")

    asyncio.run(shutdown())
    bot_running = False

# -- Gradio Web Terminal --

def live_terminal(cmd):
    if not cmd.strip():
        yield "$ "
        return
    yield f"$ {cmd}\n"
    process = subprocess.Popen(
        cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
    )
    for line in iter(process.stdout.readline, ''):
        yield line
    process.stdout.close()
    process.wait()
    yield "$ "

def run_terminal(cmd):
    return live_terminal(cmd)

def update_log_box():
    # Show last 20 logs
    logs = []
    try:
        while True:
            log = log_queue.get_nowait()
            logs.append(log)
    except Empty:
        pass

    logs.extend(telegram_cmd_logs[-20:])
    return "\n".join(logs[-20:])

# -- Gradio UI --

with gr.Blocks() as demo:
    gr.Markdown("### Live Terminal with Telegram Bot Control")

    with gr.Row():
        terminal_output = gr.Textbox(value="$ ", label="Live Terminal", lines=20, interactive=False)
        cmd_input = gr.Textbox(placeholder="Type command here and press Enter", label="Command Input")

    with gr.Row():
        start_btn = gr.Button("Start Telegram Bot")
        stop_btn = gr.Button("Stop Telegram Bot")

    log_output = gr.Textbox(value="", label="Bot Logs & Telegram Bash Command Logs", lines=15, interactive=False)

    # Command input triggers terminal
    cmd_input.submit(run_terminal, inputs=cmd_input, outputs=terminal_output)

    # Start/stop buttons update logs
    def start_click():
        start_bot()
        return update_log_box()

    def stop_click():
        stop_bot()
        return update_log_box()

    start_btn.click(start_click, outputs=log_output)
    stop_btn.click(stop_click, outputs=log_output)

    # Auto-update logs every 3 seconds
    def auto_update():
        return update_log_box()

    demo.load(auto_update, None, log_output, every=3)

demo.launch()