"""Verifiable Telemetry Orchestrator (Phase 0 MVP).

This module provides a minimal, production-oriented skeleton that:
- Collects data from toy adapters (solar meter and DER aggregator)
- Builds LocalProblem/SharedVariables/PlanDelta structures from the data
- Signs the PlanDelta in a deterministic, test-friendly way
- Produces an AuditLog and PrivacyBudget scaffold for governance
- Exposes a simple run_once() to simulate a reconciliation cycle
"""
from __future__ import annotations

from dataclasses import asdict
from datetime import datetime
from typing import Any, Dict, List
import json
import hmac
import hashlib

from energi_bridge.schemas import (
    LocalProblem,
    SharedVariables,
    PlanDelta,
    DualVariables,
    AuditLog,
    PrivacyBudget,
    RegistryMetadata,
)


def _sign_payload(payload: str, key: str) -> str:
    return hmac.new(key.encode("utf-8"), payload.encode("utf-8"), hashlib.sha256).hexdigest()


class VerifiableTelemOrchestrator:
    def __init__(self, adapters: List[Any], signing_key: str = "secret") -> None:
        self.adapters = adapters
        self.signing_key = signing_key

    def _collect_signals(self) -> Dict[str, Any]:
        signals: Dict[str, Any] = {}
        for adapter in self.adapters:
            if hasattr(adapter, "read_meter"):
                try:
                    signals["solar_meter"] = adapter.read_meter()
                except Exception:
                    signals["solar_meter"] = {"error": "read_failed"}
            if hasattr(adapter, "aggregate"):
                try:
                    signals["der_aggregator"] = adapter.aggregate()
                except Exception:
                    signals["der_aggregator"] = {"error": "aggregate_failed"}
        return signals

    def run_once(self) -> Dict[str, Any]:
        # Gather telemetry from adapters
        signals = self._collect_signals()

        # Phase-0 MVP Hard-coded skeletons to demonstrate flow
        lp = LocalProblem(
            id="lp_mvp",
            domain="GridGuard",
            assets=[getattr(a, "__class__", object).__name__ for a in self.adapters],
            constraints={"max_dispatch_kw": 5000, "min_dispatch_kw": 0},
            objective={"type": "mesh_energy_balance"},
            solver_hint=None,
        )

        sv = SharedVariables(
            version=1,
            signals=signals,
            privacy_tag="phase0",
            aggregation_method="mean",
        )

        # Simple delta reflecting new signals; sign for verifiability
        delta_payload = {"signals": signals, "ts": datetime.utcnow().isoformat()}
        delta_json = json.dumps(delta_payload, sort_keys=True)
        signature = _sign_payload(delta_json, self.signing_key)

        pd = PlanDelta(
            delta=delta_payload,
            timestamp=datetime.utcnow(),
            author="VerifiableTelemOrchestrator",
            contract_id="c0",
            signature=signature,
            safety_tags=["mesh_balancing"],
        )

        dv = DualVariables()
        al = AuditLog(entries=[{"event": "plan_delta_created", "ts": datetime.utcnow().isoformat()}], last_updated=datetime.utcnow())
        pb = PrivacyBudget(budget=1.0, spent=0.0, policy={"phase": 0})
        rm = RegistryMetadata(contract_version="0.1.0", adapter_id="verifiable-telemetry-orchestrator", replay_hint=None)

        # Return a dictionary with serializable payloads
        return {
            "local_problem": asdict(lp),
            "shared_variables": asdict(sv),
            "plan_delta": asdict(pd),
            "dual_variables": asdict(dv),
            "audit_log": asdict(al),
            "privacy_budget": asdict(pb),
            "registry_metadata": asdict(rm),
        }