from __future__ import annotations

import json
from dataclasses import dataclass, asdict, field
from typing import Dict, Any, List, Optional


def to_json(obj: Any) -> str:
    return json.dumps(obj, default=lambda o: o.__dict__, sort_keys=True)


@dataclass
class LocalExecutionTask:
    """Canonical LocalExecutionTask per instrument/venue planning unit."""
    task_id: str
    instrument: str
    venue: str
    objective: str
    constraints: Dict[str, Any] = field(default_factory=dict)

    def to_json(self) -> str:
        return to_json(asdict(self))

    def to_dict(self) -> Dict[str, Any]:
        return asdict(self)


@dataclass
class SharedMarketContext:
    """Canonical SharedMarketContext with privacy-safe signals."""
    signals: Dict[str, Any]
    version: int
    contract_id: str

    def to_json(self) -> str:
        return to_json(asdict(self))

    def to_dict(self) -> Dict[str, Any]:
        return asdict(self)


@dataclass
class PlanDelta:
    """Incremental routing/size/timing decisions with metadata."""
    delta: Dict[str, Any]
    timestamp: float
    author: str
    contract_id: str
    privacy_budget: Optional[float] = None

    def to_json(self) -> str:
        return to_json(asdict(self))

    def to_dict(self) -> Dict[str, Any]:
        return asdict(self)


@dataclass
class Attestation:
    """Cryptographic attestation for a delta or event."""
    entry: str
    signer: str
    timestamp: float
    contract_id: str
    version: int
    signature: Optional[str] = None

    def to_json(self) -> str:
        return to_json(asdict(self))

    def to_dict(self) -> Dict[str, Any]:
        return asdict(self)


@dataclass
class AuditLog:
    """Append-only log of attestations and approvals."""
    entries: List[Attestation] = field(default_factory=list)

    def add(self, attestation: Attestation) -> None:
        self.entries.append(attestation)

    def to_json(self) -> str:
        return to_json([asdict(entry) for entry in self.entries])

    def to_dict(self) -> Dict[str, Any]:
        return {"entries": [e.to_dict() for e in self.entries]}


@dataclass
class GraphOfContracts:
    """Registry for adapters and data-contract schemas."""
    registry: Dict[str, Any]
    version: int = 1
    adapters: Optional[Dict[str, Any]] = None

    def __post_init__(self) -> None:
        if self.adapters is None:
            self.adapters = self.registry

    def to_dict(self) -> Dict[str, Any]:
        return {"registry": self.registry, "version": self.version, "adapters": self.adapters}


def compute_delta(task: LocalExecutionTask, ctx: SharedMarketContext) -> PlanDelta:
    """Deterministic, minimal PlanDelta from inputs."""
    delta = {
        "action": "hold",
        "reason": "base-case",
        "task_id": task.task_id,
        "instrument": task.instrument,
        "venue": task.venue,
        "constraints_snapshot": task.constraints,
    }
    return PlanDelta(
        delta=delta,
        timestamp=0.0,
        author="exprove-solver",
        contract_id=ctx.contract_id,
        privacy_budget=0.0,
    )