"""AgentRegistry — zentrale Liste aller Specialist-Agenten + MC-Owner-Mapping.

Verhindert dass eine MC zweimal geprüft wird (oder gar nicht). Der
SSE-Test-Endpoint löst Agent-Namen über diese Registry auf.
"""

from __future__ import annotations

from ._base import BaseSpecialistAgent


class AgentRegistry:
    """Singleton-ähnliche Registry. Ein Agent registriert sich beim
    Import, der SSE-Endpoint löst auf."""

    def __init__(self) -> None:
        self._agents: dict[str, BaseSpecialistAgent] = {}
        # MC-ID → agent_id. Verhindert Doppel-Ownership.
        self._mc_owner: dict[str, str] = {}

    def register(self, agent: BaseSpecialistAgent) -> None:
        if not agent.agent_id:
            raise ValueError("agent.agent_id darf nicht leer sein")
        if agent.agent_id in self._agents:
            # Re-register erlaubt (z.B. Hot-Reload), aber überschreibt
            self._agents[agent.agent_id] = agent
            return
        self._agents[agent.agent_id] = agent
        for mc_id in agent.owned_mc_ids:
            existing = self._mc_owner.get(mc_id)
            if existing and existing != agent.agent_id:
                raise ValueError(
                    f"MC {mc_id} bereits von Agent {existing} owned — "
                    f"jetzt versucht {agent.agent_id}. Konflikt auflösen."
                )
            self._mc_owner[mc_id] = agent.agent_id

    def get(self, agent_id: str) -> BaseSpecialistAgent | None:
        return self._agents.get(agent_id)

    def list_agents(self) -> list[dict]:
        """Public listing für das Frontend (Agent-Wähler)."""
        return [
            {
                "agent_id": a.agent_id,
                "agent_version": a.agent_version,
                "doc_type": a.doc_type,
                "mc_count": len(a.owned_mc_ids),
            }
            for a in self._agents.values()
        ]

    def owner_of(self, mc_id: str) -> str | None:
        return self._mc_owner.get(mc_id)


REGISTRY = AgentRegistry()
