"""EnergiaBridge: Canonical bridge between GridVerse primitives and a vendor-agnostic
interoperability layer (CatOpt-style).

This is a minimal, production-ready skeleton intended to anchor the interoperability
story described in the GridVerse MVP plan. It provides small, well-defined mapping
points between GridVerse core contracts (Objects, Morphisms, PlanDelta, etc.) and a
canonical representation used by potential adapters and external runtimes.

Note: This module is intentionally lightweight. Real deployments should augment the
mapping logic with proper schema validation, versioning, cryptographic attestation,
and TLS transport glue.
"""

from __future__ import annotations

from dataclasses import dataclass, field
from typing import Any, Dict

# Lightweight import to avoid circular imports at module import time.
try:
    from gridverse.registry import GraphContractRegistry
except Exception:  # pragma: no cover
    GraphContractRegistry = object  # type: ignore

@dataclass
class CanonicalBundle:
    """Canonical representation that adapters can consume/emit.

    - objects: canonical LocalProblem-like entities per-site
    - morphisms: canonical SharedVariables/DualVariables as channels
    - duals: coupling/duality signals between local problems and global constraints
    - plan_delta: incremental optimization actions to apply
    - governance: lightweight per-message metadata for audit/logs
    """

    objects: Dict[str, Any] = field(default_factory=dict)
    morphisms: Dict[str, Any] = field(default_factory=dict)
    duals: Dict[str, Any] = field(default_factory=dict)
    plan_delta: Dict[str, Any] = field(default_factory=dict)
    governance: Dict[str, Any] = field(default_factory=dict)

    def __repr__(self) -> str:
        return (
            f"CanonicalBundle(objects={len(self.objects)}, morphisms={len(self.morphisms)}, "
            f"duals={len(self.duals)}, plan_delta={len(self.plan_delta)}, governance={len(self.governance)})"
        )


def to_canonical(local_problem: Dict[str, Any], shared_vars: Dict[str, Any],
                 plan_delta: Dict[str, Any], version: str | None = None) -> CanonicalBundle:
    """Convert GridVerse primitives to a CanonicalBundle.

    This is a thin wrapper that can be extended with proper validation and versioning.
    """
    bundle = CanonicalBundle()
    bundle.objects = {
        k: v for k, v in (local_problem or {}).items()
    }
    bundle.morphisms = {
        k: v for k, v in (shared_vars or {}).items()
    }
    bundle.duals = {}  # Reserved for dual variables mapping; filled by adapters as needed
    bundle.plan_delta = plan_delta or {}
    bundle.governance = {
        "version": version or "0.1.0",
        "timestamp": __import__('time').time(),
        "note": "generated via to_canonical"
    }
    return bundle


def from_canonical(bundle: CanonicalBundle) -> Dict[str, Any]:
    """Inverse mapping: CanonicalBundle -> local primitives (placeholders).

    This is a minimal placeholder returning the contained dictionaries.
    Real usage should reconstruct proper GridVerse contracts with validation.
    """
    local_problem = dict(bundle.objects)
    shared_vars = dict(bundle.morphisms)
    plan_delta = dict(bundle.plan_delta)
    governance = dict(bundle.governance)
    return {
        "local_problem": local_problem,
        "shared_vars": shared_vars,
        "plan_delta": plan_delta,
        "governance": governance,
    }


__all__ = ["CanonicalBundle", "to_canonical", "from_canonical"]


def bootstrap_contracts(registry: "GraphContractRegistry") -> None:
    """Register a minimal set of contract schemas into the provided registry.

    This function is intended as an MVP bootstrap helper so adapters can rely on
    a versioned, conformance-checked contract namespace without requiring a
    full deployment environment. It registers a LocalProblem, SharedVariables,
    and PlanDelta contract skeletons that adapters can reference during
    development and testing.
    
    Note: The input registry might be a thin in-process registry or a remote
    service; this function only uses a simple interface: register_contract. If
    GraphContractRegistry is not available at import time, this function is a no-op.
    """
    # Be resilient to environments where a concrete registry class isn't wired up
    # yet. If the registry exposes a simple 'register_contract' method, use it.
    if not hasattr(registry, "register_contract"):
        return

    # Example schema shapes. They are intentionally small and self-describing.
    local_problem_schema = {
        "name": "LocalProblem",
        "version": "0.1.0",
        "schema": {
            "type": "object",
            "properties": {
                "site_id": {"type": "string"},
                "description": {"type": "string"},
                "variables": {"type": "object"},
            },
            "required": ["site_id", "description"],
        },
    }
    shared_variables_schema = {
        "name": "SharedVariables",
        "version": "0.1.0",
        "schema": {
            "type": "object",
            "properties": {
                "signals": {"type": "object"},
            },
        },
    }
    plan_delta_schema = {
        "name": "PlanDelta",
        "version": "0.1.0",
        "schema": {
            "type": "object",
            "properties": {
                "delta_id": {"type": "string"},
                "changes": {"type": "object"},
            },
        },
    }

    registry.register_contract("LocalProblem", local_problem_schema["version"], local_problem_schema["schema"])
    registry.register_contract("SharedVariables", shared_variables_schema["version"], shared_variables_schema["schema"])
    registry.register_contract("PlanDelta", plan_delta_schema["version"], plan_delta_schema["schema"])