import os
import gradio as gr
import subprocess
import sys
import json
import threading
import time

# Ruta al server MCP
SERVER_PATH = os.path.abspath(os.path.join("mcp_servers", "stdio_report_gen_server.py"))

# Mantener el proceso del servidor MCP abierto durante toda la sesión
def start_mcp_server():
    proc = subprocess.Popen(
        [sys.executable, SERVER_PATH],
        stdin=subprocess.PIPE,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True,
        bufsize=1
    )
    print(f"[DEBUG] MCP STDIN: {proc.stdin}, STDOUT: {proc.stdout}, STDERR: {proc.stderr}")
    return proc

mcp_proc = start_mcp_server()
lock = threading.Lock()  # Para evitar condiciones de carrera en stdio

# Lee stderr de MCP en un hilo y guarda los logs
stderr_logs = []
def read_stderr(proc):
    while True:
        line = proc.stderr.readline()
        if not line:
            break
        stderr_logs.append(line)
        print("[MCP STDERR]", line.strip())

stderr_thread = threading.Thread(target=read_stderr, args=(mcp_proc,), daemon=True)
stderr_thread.start()

# Comunicación usando JSON-RPC mínimo con timeout y logs

def call_mcp_server(prompt):
    request = {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "get_current_stock_price",  # Cambiado para probar el método
        "params": [prompt]
    }
    try:
        with lock:
            print(f"[APP] Enviando petición al MCP: {json.dumps(request)}")
            mcp_proc.stdin.write(json.dumps(request) + "\n")
            mcp_proc.stdin.flush()
            # Esperar respuesta con timeout
            start_time = time.time()
            response_line = ''
            while True:
                if mcp_proc.stdout.closed:
                    return "El servidor MCP se cerró inesperadamente."
                if mcp_proc.stdout.readable():
                    response_line = mcp_proc.stdout.readline()
                    print(f"[APP] Recibido de MCP: {response_line}")
                    if response_line.strip():
                        break
                if time.time() - start_time > 30:
                    return f"Timeout esperando respuesta del servidor MCP. Logs recientes: {''.join(stderr_logs[-10:])}"
                time.sleep(0.1)
        if not response_line:
            return "No se recibió respuesta del servidor MCP."
        response = json.loads(response_line)
        if "result" in response:
            return response["result"]
        elif "error" in response:
            return f"Error del servidor MCP: {response['error']}\nLogs recientes: {''.join(stderr_logs[-10:])}"
        else:
            return f"Respuesta inesperada del servidor MCP. Logs recientes: {''.join(stderr_logs[-10:])}"
    except Exception as e:
        return f"Error comunicando con el servidor MCP: {str(e)}\nLogs recientes: {''.join(stderr_logs[-10:])}"

with gr.Blocks() as demo:
    gr.Markdown("# Generador de Reportes Financieros (Claude + MCP)")
    prompt = gr.Textbox(label="Información financiera de la empresa")
    output = gr.Textbox(label="Reporte generado")
    btn = gr.Button("Generar reporte")
    btn.click(fn=call_mcp_server, inputs=prompt, outputs=output)

if __name__ == "__main__":
    demo.launch()