import logging
from typing import Dict, Any
import httpx

logging.basicConfig(
    level=logging.DEBUG, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)


class AgrotaMcpClient:
    def __init__(self, server_url: str):
        # Change from SSE URL to HTTP URL
        self.server_url = server_url.replace("/sse", "/mcp")
        self.client = httpx.AsyncClient(timeout=120.0)
        self._is_connected = False

    async def __aenter__(self):
        await self.connect()
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        await self.disconnect()

    async def disconnect(self):
        """Cierra el cliente HTTP."""
        if self.client:
            try:
                await self.client.aclose()
            except Exception as e:
                logger.error(f"Error al cerrar cliente HTTP: {e}")
            finally:
                self._is_connected = False
        logger.info("Desconectado.")

    def is_connected(self) -> bool:
        """Verifica si el cliente está activo."""
        return self._is_connected

    async def connect(self):
        """Marca el cliente como conectado (sin verificación real de conexión)."""
        if self._is_connected:
            return

        logger.info(f"Cliente HTTP listo para {self.server_url}")
        self._is_connected = True

    async def list_tools(self):
        """Lista las herramientas disponibles (simulado para compatibilidad)."""
        # Simulado - solo devuelve consultarAgrota
        from collections import namedtuple

        ToolsList = namedtuple("ToolsList", ["tools"])
        Tool = namedtuple("Tool", ["name", "description"])
        return ToolsList(
            tools=[
                Tool(
                    name="consultarAgrota",
                    description="Transforma una solicitud en lenguaje natural a DAX y consulta el Power BI de Agrota.",
                )
            ]
        )

    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> str:
        """Llama al endpoint HTTP directamente."""
        if tool_name != "consultarAgrota":
            raise RuntimeError(f"Herramienta desconocida: {tool_name}")

        try:
            logger.info(f"🌐 Enviando solicitud HTTP POST a {self.server_url}")
            response = await self.client.post(
                self.server_url,
                json={"prompt": arguments.get("prompt", "")},
                headers={"Content-Type": "application/json"},
            )

            if response.status_code == 200:
                data = response.json()
                return data.get("result", "Sin resultado")
            else:
                logger.error(f"❌ Error HTTP {response.status_code}: {response.text}")
                return f"Error del servidor: {response.status_code}"
        except Exception as e:
            logger.error(f"❌ Error llamando al endpoint HTTP: {e}")
            return f"Error al ejecutar la herramienta: {e}"