"""Core library for OpenFederatedCompiler MVP.

This package provides minimal data structures and a tiny CRDT-like delta merger
to illustrate the architecture described in the project brief. It is intentionally
small but designed to be extended into a production-grade MVP.
"""

from __future__ import annotations

from dataclasses import dataclass, field
from typing import Dict, Optional
import time


@dataclass
class LocalPolicy:
    id: str
    device_type: str
    objective: str
    constraints: Dict[str, any] = field(default_factory=dict)
    solver_hint: Optional[str] = None


@dataclass
class SharedVariables:
    version: int = 0
    priors: Dict[str, float] = field(default_factory=dict)
    forecasts: Dict[str, float] = field(default_factory=dict)


@dataclass
class PlanDelta:
    delta: Dict[str, any]
    timestamp: float = field(default_factory=lambda: time.time())
    author: str = "anonymous"
    contract_id: str = "unknown"
    signature: Optional[str] = None


@dataclass
class DualVariables:
    multipliers: Dict[str, float] = field(default_factory=dict)


@dataclass
class PrivacyBudget:
    signal: str
    limit: int
    remaining: int
    expiry: Optional[str] = None


@dataclass
class AuditLog:
    entry: str
    signer: str
    timestamp: float = field(default_factory=time.time)
    contract_id: str = "unknown"
    version: int = 0


@dataclass
class PolicyBlock:
    safety: str
    exposure_controls: Dict[str, any] = field(default_factory=dict)


@dataclass
class GraphOfContractsEntry:
    adapter_id: str
    supported_domains: tuple
    contract_version: str


class GraphOfContracts:
    """A tiny registry for adapter contracts."""

    def __init__(self) -> None:
        self._entries: Dict[str, GraphOfContractsEntry] = {}

    def register(self, key: str, entry: GraphOfContractsEntry) -> None:
        self._entries[key] = entry

    def get(self, key: str) -> GraphOfContractsEntry | None:
        return self._entries.get(key)

    def list(self) -> Dict[str, GraphOfContractsEntry]:
        return dict(self._entries)


class DeltaEngine:
    """A small CRDT-like delta merger for LocalPolicy updates.

    This is intentionally simple: a PlanDelta.delta is merged into LocalPolicy.constraints
    and object fields are updated if present.
    """

    @staticmethod
    def merge(local: LocalPolicy, delta: PlanDelta) -> LocalPolicy:
        # Apply changes from delta.delta onto local policy. This is a naive merge suitable for MVP.
        for k, v in delta.delta.items():
            if hasattr(local, k):
                setattr(local, k, v)
            else:
                local.constraints[k] = v  # fallback to constraints for unknown top-level keys
        return local


__all__ = [
    "LocalPolicy",
    "SharedVariables",
    "PlanDelta",
    "DualVariables",
    "PrivacyBudget",
    "AuditLog",
    "PolicyBlock",
    "GraphOfContractsEntry",
    "GraphOfContracts",
    "DeltaEngine",
]