"""Graph-of-Contracts (GoC) registry."""
from __future__ import annotations
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional

from .adapters.broker import BrokerAdapter
from .adapters.price_feed import PriceFeedAdapter
from .core import HedgeDelta


@dataclass
class GoCRegistry:
    """Registry for adapters and data contracts."""
    adapters: Dict[str, object] = field(default_factory=dict)
    contracts: Dict[str, str] = field(default_factory=dict)
    metadata: Dict[str, Any] = field(default_factory=dict)

    def __post_init__(self):
        # Initialize to an empty mapping if not provided
        if self.adapters is None:
            self.adapters = {}

    def register_adapter(self, adapter) -> None:
        self.adapters[adapter.name] = adapter

    def get_adapter(self, name: str) -> Optional[object]:
        return self.adapters.get(name)

    def register_contract(self, name: str, version: str) -> None:
        self.contracts[name] = version

    def get_contract(self, name: str) -> Optional[str]:
        return self.contracts.get(name)

    def conformance_report(self, adapter_name: str) -> Dict[str, Any]:
        adapter = self.get_adapter(adapter_name)
        if adapter is None:
            return {"adapter": adapter_name, "registered": False, "conforms": False}

        required_methods: List[str] = []
        if isinstance(adapter, PriceFeedAdapter):
            required_methods = ["generate_signal", "conformance_contract"]
        elif isinstance(adapter, BrokerAdapter):
            required_methods = ["send_delta", "conformance_contract"]

        missing = [method for method in required_methods if not hasattr(adapter, method)]
        return {
            "adapter": adapter_name,
            "registered": True,
            "conforms": not missing,
            "missing": missing,
            "contract": getattr(adapter, "conformance_contract", lambda: None)(),
        }


class GraphOfContracts:
    """Catalog for contract versions and replay metadata."""
    def __init__(self) -> None:
        self.contracts: Dict[str, Dict[str, Any]] = {}

    def register_contract(self, name: str, version: str, schema: Optional[Dict[str, Any]] = None) -> None:
        self.contracts[name] = {"version": version, "schema": schema or {}}

    def get_contract(self, name: str) -> Optional[Dict[str, Any]]:
        return self.contracts.get(name)

    def list_contracts(self):
        return list(self.contracts.items())

    def to_dict(self) -> Dict[str, Dict[str, Any]]:
        return dict(self.contracts)


__all__ = ["GoCRegistry", "GraphOfContracts"]