from __future__ import annotations

from dataclasses import asdict
from typing import Dict, Any

from .dsl import LocalProblem, SharedVariables, PlanDelta


class EnergiBridge:
    """Minimal EnergiBridge-like interoperability bridge.

    This is a tiny, production-light skeleton that maps existing ExoRoute
    primitives into a canonical, CatOpt-style IR. It is intentionally small
    to keep the MVP focused while providing a hook for future integration with
    other adapters and governance modules.
    """

    def __init__(self) -> None:
        # In a real system this would be a persistent registry of adapters and
        # schemas. For this skeleton we just keep a minimal in-memory map.
        self._registry: Dict[str, Any] = {}

    def register_adapter(self, adapter_id: str, contract_version: str, domains: list[str]) -> None:
        self._registry[adapter_id] = {
            "contract_version": contract_version,
            "domains": domains,
        }

    def map_to_ir(self, lp: LocalProblem, sv: SharedVariables, pd: PlanDelta) -> Dict[str, Any]:
        """Create a canonical IR payload from ExoRoute primitives.

        This payload is deliberately lightweight but designed to be serializable
        and replayable. It can be extended to include per-message metadata,
        signatures, and versioning as the project matures.
        """
        ir = {
            "object": {
                "type": "LocalProblem",
                "payload": asdict(lp),
            },
            "morphisms": {
                "shared_variables": asdict(sv) if isinstance(sv, SharedVariables) else sv,
                "dual_variables": {},  # placeholder for future expansion
            },
            "plan_delta": asdict(pd) if isinstance(pd, PlanDelta) else pd,
        }
        return ir

    def __repr__(self) -> str:
        return f" EnergiBridge(registry_entries={len(self._registry)})"