"""
Sistema de Customer Service Multi-Agent
- Cada agente usa MCP para acceder a sus herramientas
- Los agentes se comunican entre sí via A2A
"""

# Agente de Soporte (usa MCP para Zendesk, Knowledge Base)
class SupportAgent:
    def __init__(self):
        # MCP connections (vertical integration)
        self.mcp_zendesk = MCPClient("zendesk-server")
        self.mcp_kb = MCPClient("knowledge-base-server")

        # A2A para colaborar con otros agentes
        self.a2a_client = A2AClient()

    async def handle_ticket(self, ticket_id: str):
        # 1. Usa MCP para obtener datos del ticket
        ticket = await self.mcp_zendesk.call("get_ticket", ticket_id)

        # 2. Si es tema financiero, delega via A2A
        if ticket.category == "billing":
            financial_agent = await self.a2a_client.discover(
                "/.well-known/agent.json",
                skill="billing-resolution"
            )
            result = await self.a2a_client.send_task(
                agent=financial_agent,
                task="resolve_billing_issue",
                context=ticket
            )
            return result

        # 3. Si no, resuelve localmente con knowledge base (MCP)
        solution = await self.mcp_kb.call("search", ticket.description)
        return solution

# Agente Financiero (expone A2A, usa MCP para Stripe/SAP)
class FinancialAgent(A2AServer):
    def __init__(self):
        self.mcp_stripe = MCPClient("stripe-server")
        self.mcp_sap = MCPClient("sap-server")

    # Skill expuesta via A2A
    @a2a_skill("billing-resolution")
    async def resolve_billing(self, task: A2ATask):
        # Usa MCP para acceder a sistemas de billing
        invoice = await self.mcp_stripe.call("get_invoice", task.context.invoice_id)

        if invoice.status == "overdue":
            # Aplicar descuento y notificar
            await self.mcp_stripe.call("apply_credit", invoice.id, amount=50)

        return A2AResponse(
            status="completed",
            result={"resolution": "Credit applied", "amount": 50}
        )

"""
Registry Centralizado de Agentes A2A
"""
from typing import List, Optional
from dataclasses import dataclass
from a2a import AgentCard

@dataclass
class AgentRegistryEntry:
    agent_card: AgentCard
    category: str
    tags: List[str]
    status: str  # "active", "deprecated", "testing"
    version: str
    last_health_check: str

class A2ARegistry:
    """
    Registry centralizado para gestionar agentes A2A enterprise.
    En producción, respaldado por base de datos (PostgreSQL, MongoDB).
    """

    def __init__(self):
        self._agents: dict[str, AgentRegistryEntry] = {}

    def register(self, entry: AgentRegistryEntry) -> None:
        """Registra un nuevo agente o actualiza uno existente"""
        key = f"{entry.agent_card.provider['organization']}/" \
              f"{entry.agent_card.name}"
        self._agents[key] = entry
        print(f"✅ Agente registrado: {key}")

    def discover_by_skill(self, skill_id: str) -> List[AgentCard]:
        """Encuentra agentes que ofrecen una skill específica"""
        results = []
        for entry in self._agents.values():
            if entry.status != "active":
                continue
            for skill in entry.agent_card.skills:
                if skill.id == skill_id:
                    results.append(entry.agent_card)
                    break
        return results

    def discover_by_category(self, category: str) -> List[AgentCard]:
        """Encuentra agentes por categoría (finance, support, etc.)"""
        return [
            entry.agent_card
            for entry in self._agents.values()
            if entry.category == category and entry.status == "active"
        ]

    def discover_by_tags(self, tags: List[str]) -> List[AgentCard]:
        """Encuentra agentes que tengan TODOS los tags especificados"""
        return [
            entry.agent_card
            for entry in self._agents.values()
            if set(tags).issubset(set(entry.tags))
               and entry.status == "active"
        ]


# Uso del registry
registry = A2ARegistry()

# Registrar agentes
registry.register(AgentRegistryEntry(
    agent_card=sentiment_agent_card,
    category="nlp",
    tags=["sentiment", "text-analysis", "customer-feedback"],
    status="active",
    version="1.0.0",
    last_health_check="2026-01-12T10:00:00Z"
))

# Descubrir agentes
nlp_agents = registry.discover_by_category("nlp")
sentiment_agents = registry.discover_by_skill("analyze-sentiment")

"""
Middleware de Observability para A2A con OpenTelemetry
"""
import time
import uuid
from opentelemetry import trace, metrics
from opentelemetry.trace import Status, StatusCode
from a2a import TaskManager, TaskRequest, TaskResponse

tracer = trace.get_tracer("a2a.agents")
meter = metrics.get_meter("a2a.agents")

# Métricas
task_counter = meter.create_counter(
    "a2a.tasks.total",
    description="Total de tareas procesadas"
)
task_duration = meter.create_histogram(
    "a2a.tasks.duration_ms",
    description="Duración de tareas en ms"
)
task_errors = meter.create_counter(
    "a2a.tasks.errors",
    description="Total de errores"
)


class ObservableTaskManager(TaskManager):
    """
    Wrapper que añade observability a cualquier TaskManager
    """

    def __init__(self, inner_manager: TaskManager, agent_name: str):
        self.inner = inner_manager
        self.agent_name = agent_name

    async def on_send_task(self, request: TaskRequest) -> TaskResponse:
        # Generar trace ID si no existe
        trace_id = request.metadata.get("trace_id", str(uuid.uuid4()))

        # Iniciar span de OpenTelemetry
        with tracer.start_as_current_span(
            f"a2a.task.{request.skill_id}",
            attributes={
                "a2a.agent": self.agent_name,
                "a2a.skill_id": request.skill_id,
                "a2a.task_id": request.task_id,
                "a2a.trace_id": trace_id
            }
        ) as span:
            start_time = time.time()

            try:
                # Ejecutar tarea real
                response = await self.inner.on_send_task(request)

                # Registrar éxito
                duration_ms = (time.time() - start_time) * 1000
                task_counter.add(1, {"agent": self.agent_name, "status": "success"})
                task_duration.record(duration_ms, {"agent": self.agent_name})

                span.set_status(Status(StatusCode.OK))
                span.set_attribute("a2a.response.status", str(response.status))

                return response

            except Exception as e:
                # Registrar error
                duration_ms = (time.time() - start_time) * 1000
                task_counter.add(1, {"agent": self.agent_name, "status": "error"})
                task_errors.add(1, {"agent": self.agent_name, "error_type": type(e).__name__})
                task_duration.record(duration_ms, {"agent": self.agent_name})

                span.set_status(Status(StatusCode.ERROR, str(e)))
                span.record_exception(e)

                raise


# Uso:
# inner_manager = MiTaskManager()
# observable_manager = ObservableTaskManager(inner_manager, "sentiment-agent")
# server = A2AServer(task_manager=observable_manager, ...)

Recursos Adicionales

• 📄 Especificación Oficial A2A Protocol
• 💻 Repositorio GitHub A2A
• 🐍 Python SDK Oficial
• 📖 Anuncio Oficial de Google
• 🔐 Guía Auth0: MCP vs A2A

Lo que necesitas:

• ✓Python >= 3.12 (requerido por el SDK)
• ✓uv como package manager (recomendado) o pip
• ✓Conocimiento básico de asyncio en Python

# Crear directorio del proyecto
mkdir mi-agente-a2a && cd mi-agente-a2a

# Inicializar proyecto con uv (recomendado)
uv init

# Instalar SDK de A2A
uv add a2a-sdk

# O con pip tradicional
pip install a2a-sdk

# Verificar instalación
python -c "from a2a import A2AServer; print('A2A SDK instalado correctamente')"

"""
Sentiment Analysis Agent - Expone análisis de sentimiento via A2A
"""
import asyncio
from a2a import (
    A2AServer,
    AgentCard,
    AgentSkill,
    TaskManager,
    TaskRequest,
    TaskResponse,
    TaskStatus
)

# Definir las skills que expone este agente
SENTIMENT_SKILL = AgentSkill(
    id="analyze-sentiment",
    name="Análisis de Sentimiento",
    description="Analiza el sentimiento de un texto y devuelve "
                "score positivo/negativo/neutro con confianza",
    inputModes=["text/plain", "application/json"],
    outputModes=["application/json"],
    examples=[
        {
            "name": "Análisis básico",
            "input": "Me encanta este producto, funciona perfectamente!"
        }
    ]
)

# Definir la Agent Card
AGENT_CARD = AgentCard(
    name="Sentiment Analysis Agent",
    description="Agente especializado en análisis de sentimiento "
                "para feedback de clientes, reviews y mensajes",
    url="http://localhost:8080",
    version="1.0.0",
    provider={
        "organization": "BCloud Solutions",
        "contactEmail": "ai@bcloud.consulting"
    },
    capabilities={
        "streaming": False,
        "pushNotifications": False
    },
    skills=[SENTIMENT_SKILL]
)


class SentimentTaskManager(TaskManager):
    """
    Implementa la lógica de negocio del agente.
    Cada skill definida en la Agent Card se maneja aquí.
    """

    async def on_send_task(self, request: TaskRequest) -> TaskResponse:
        """
        Procesa una tarea recibida via A2A.

        Args:
            request: Contiene el skill_id, input y metadata

        Returns:
            TaskResponse con el resultado o error
        """
        skill_id = request.skill_id

        if skill_id == "analyze-sentiment":
            return await self._analyze_sentiment(request)
        else:
            return TaskResponse(
                task_id=request.task_id,
                status=TaskStatus.FAILED,
                error=f"Skill desconocida: {skill_id}"
            )

    async def _analyze_sentiment(self, request: TaskRequest) -> TaskResponse:
        """
        Implementación del análisis de sentimiento.
        En producción, esto llamaría a un modelo real (OpenAI, HuggingFace, etc.)
        """
        text = request.input.get("text", "")

        if not text:
            return TaskResponse(
                task_id=request.task_id,
                status=TaskStatus.FAILED,
                error="El campo 'text' es requerido"
            )

        # Análisis simple (en producción usar modelo real)
        positive_words = ["encanta", "excelente", "perfecto", "genial", "increíble"]
        negative_words = ["horrible", "terrible", "malo", "pésimo", "odio"]

        text_lower = text.lower()
        positive_count = sum(1 for w in positive_words if w in text_lower)
        negative_count = sum(1 for w in negative_words if w in text_lower)

        if positive_count > negative_count:
            sentiment = "positive"
            confidence = min(0.5 + (positive_count * 0.15), 0.95)
        elif negative_count > positive_count:
            sentiment = "negative"
            confidence = min(0.5 + (negative_count * 0.15), 0.95)
        else:
            sentiment = "neutral"
            confidence = 0.6

        result = {
            "sentiment": sentiment,
            "confidence": round(confidence, 2),
            "analysis": {
                "positive_signals": positive_count,
                "negative_signals": negative_count,
                "text_length": len(text)
            }
        }

        return TaskResponse(
            task_id=request.task_id,
            status=TaskStatus.COMPLETED,
            result=result
        )


async def main():
    """Inicia el servidor A2A"""
    task_manager = SentimentTaskManager()
    server = A2AServer(
        agent_card=AGENT_CARD,
        task_manager=task_manager,
        host="0.0.0.0",
        port=8080
    )

    print("🚀 Sentiment Agent iniciado en http://localhost:8080")
    print("📄 Agent Card disponible en http://localhost:8080/.well-known/agent.json")

    await server.start()


if __name__ == "__main__":
    asyncio.run(main())

"""
Client Agent - Descubre y usa otros agentes via A2A
"""
import asyncio
from a2a import A2AClient, AgentCard

async def main():
    # Crear cliente A2A
    client = A2AClient()

    # 1. DISCOVERY: Obtener Agent Card del servidor
    print("🔍 Descubriendo agente de sentimiento...")

    try:
        agent_card: AgentCard = await client.discover(
            "http://localhost:8080/.well-known/agent.json"
        )
        print(f"✅ Encontrado: {agent_card.name}")
        print(f"   Skills: {[s.name for s in agent_card.skills]}")
    except Exception as e:
        print(f"❌ Error descubriendo agente: {e}")
        return

    # 2. INVOKE: Enviar tarea al agente
    texts_to_analyze = [
        "Me encanta este producto, funciona perfectamente!",
        "Terrible experiencia, nunca más compraré aquí",
        "El servicio es normal, nada especial"
    ]

    print("\n📊 Analizando textos...\n")

    for text in texts_to_analyze:
        # Enviar tarea A2A
        response = await client.send_task(
            agent_url=agent_card.url,
            skill_id="analyze-sentiment",
            input_data={"text": text}
        )

        if response.status == "completed":
            result = response.result
            emoji = "😊" if result["sentiment"] == "positive" else \
                    "😞" if result["sentiment"] == "negative" else "😐"

            print(f"Texto: \"{text[:50]}...\"")
            print(f"  {emoji} Sentimiento: {result['sentiment']}")
            print(f"  📈 Confianza: {result['confidence']*100:.0f}%")
            print()
        else:
            print(f"❌ Error: {response.error}")


if __name__ == "__main__":
    asyncio.run(main())

# Terminal 1: Iniciar el servidor (agente de sentimiento)
python sentiment_agent.py

# Output esperado:
# 🚀 Sentiment Agent iniciado en http://localhost:8080
# 📄 Agent Card disponible en http://localhost:8080/.well-known/agent.json

# Terminal 2: Ejecutar el cliente
python client_agent.py

# Output esperado:
# 🔍 Descubriendo agente de sentimiento...
# ✅ Encontrado: Sentiment Analysis Agent
#    Skills: ['Análisis de Sentimiento']
#
# 📊 Analizando textos...
#
# Texto: "Me encanta este producto, funciona perfectamente..."
#   😊 Sentimiento: positive
#   📈 Confianza: 65%
#
# Texto: "Terrible experiencia, nunca más compraré aquí..."
#   😞 Sentimiento: negative
#   📈 Confianza: 65%
#
# Texto: "El servicio es normal, nada especial..."
#   😐 Sentimiento: neutral
#   📈 Confianza: 60%

"""
Agente A2A Seguro con OAuth2 para Producción
"""
import asyncio
from a2a import (
    A2AServer,
    AgentCard,
    AgentSkill,
    TaskManager,
    SecurityScheme,
    OAuth2Flow
)
from a2a.security import OAuth2Validator, BearerTokenAuth

# Configuración OAuth2
OAUTH2_CONFIG = {
    "issuer": "https://auth.miempresa.com",
    "token_url": "https://auth.miempresa.com/oauth/token",
    "jwks_uri": "https://auth.miempresa.com/.well-known/jwks.json",
    "audience": "a2a-agents",
    "required_scopes": ["read:tasks", "write:analysis"]
}

# Agent Card con autenticación OAuth2
SECURE_AGENT_CARD = AgentCard(
    name="Secure Financial Agent",
    description="Agente financiero enterprise con autenticación OAuth2",
    url="https://agents.miempresa.com/financial",
    version="2.0.0",
    provider={
        "organization": "MiEmpresa S.A.",
        "contactEmail": "security@miempresa.com"
    },
    # Definir esquemas de seguridad soportados
    securitySchemes={
        "oauth2": SecurityScheme(
            type="oauth2",
            flows={
                "clientCredentials": OAuth2Flow(
                    tokenUrl=OAUTH2_CONFIG["token_url"],
                    scopes={
                        "read:tasks": "Leer tareas y resultados",
                        "write:analysis": "Crear nuevos análisis"
                    }
                )
            }
        ),
        "apiKey": SecurityScheme(
            type="apiKey",
            name="X-API-Key",
            in_="header"
        )
    },
    # Especificar qué esquemas se requieren
    security=[
        {"oauth2": ["read:tasks"]},  # OAuth2 con scope mínimo
        {"apiKey": []}               # O API key (fallback)
    ],
    skills=[
        AgentSkill(
            id="financial-analysis",
            name="Análisis Financiero",
            description="Análisis de métricas financieras empresariales",
            inputModes=["application/json"],
            outputModes=["application/json"]
        )
    ]
)


class SecureTaskManager(TaskManager):
    """Task Manager con validación de seguridad"""

    def __init__(self, oauth_validator: OAuth2Validator):
        self.oauth_validator = oauth_validator

    async def on_send_task(self, request, auth_context):
        """
        El auth_context contiene información del token validado:
        - claims: JWT claims decodificados
        - scopes: Scopes autorizados
        - client_id: ID del cliente que hace la petición
        """
        # Verificar scope específico para esta operación
        if "write:analysis" not in auth_context.scopes:
            raise PermissionError(
                f"Scope 'write:analysis' requerido. "
                f"Tienes: {auth_context.scopes}"
            )

        # Log de auditoría
        print(f"📝 Audit: Cliente {auth_context.client_id} "
              f"ejecutando {request.skill_id}")

        # Procesar tarea...
        return await self._process_financial_analysis(request)


async def main():
    # Configurar validador OAuth2
    oauth_validator = OAuth2Validator(
        issuer=OAUTH2_CONFIG["issuer"],
        audience=OAUTH2_CONFIG["audience"],
        jwks_uri=OAUTH2_CONFIG["jwks_uri"]
    )

    task_manager = SecureTaskManager(oauth_validator)

    # Configurar servidor con TLS
    server = A2AServer(
        agent_card=SECURE_AGENT_CARD,
        task_manager=task_manager,
        host="0.0.0.0",
        port=443,
        # Configuración TLS
        ssl_certfile="/etc/ssl/certs/agent.crt",
        ssl_keyfile="/etc/ssl/private/agent.key",
        # Autenticación
        auth_handler=BearerTokenAuth(oauth_validator)
    )

    print("🔒 Secure Agent iniciado en https://agents.miempresa.com/financial")
    await server.start()


if __name__ == "__main__":
    asyncio.run(main())

"""
Cliente A2A Seguro con OAuth2 Client Credentials
"""
import asyncio
from a2a import A2AClient
from a2a.security import OAuth2ClientCredentials

async def main():
    # Configurar autenticación OAuth2
    auth = OAuth2ClientCredentials(
        client_id="mi-agente-cliente",
        client_secret="$SUPER_SECRET_KEY",  # Usar secrets manager!
        token_url="https://auth.miempresa.com/oauth/token",
        scopes=["read:tasks", "write:analysis"]
    )

    # Cliente con autenticación
    client = A2AClient(auth=auth)

    # El cliente automáticamente:
    # 1. Obtiene token OAuth2 antes de la primera petición
    # 2. Incluye el token en el header Authorization
    # 3. Refresca el token si expira

    agent_card = await client.discover(
        "https://agents.miempresa.com/financial/.well-known/agent.json"
    )

    response = await client.send_task(
        agent_url=agent_card.url,
        skill_id="financial-analysis",
        input_data={"portfolio_id": "P-12345"}
    )

    print(f"Resultado: {response.result}")


if __name__ == "__main__":
    asyncio.run(main())