"""
EVEZ Live-Reasoning Broadcaster
Broadcasts cognitive events to GitHub (runs/live-reasoning) and optionally
YouTube/Telegram. Formats FIRE events, specimen classifications, and training
miracles into readable reasoning traces.
"""
import json
import time
import hashlib
import os
from dataclasses import dataclass, asdict
from typing import Optional
import subprocess


@dataclass
class BroadcastEntry:
    entry_id: str
    event_type: str  # "fire" | "specimen" | "miracle" | "transition" | "loop_tick"
    content: str
    metadata: dict
    timestamp: float
    broadcast_to: list[str]  # ["github", "telegram", "youtube"]


class LiveReasoningBroadcaster:
    def __init__(self, repo: str = "EvezArt/evez-vcl", branch: str = "main",
                 runs_dir: str = "runs/live-reasoning"):
        self.repo = repo
        self.branch = branch
        self.runs_dir = runs_dir
        self.entries: list[BroadcastEntry] = []
        self.github_token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN", "")

    def format_fire_event(self, event) -> str:
        return (
            f"## 🔥 FIRE Event @ tick {event.tick}\n"
            f"- **Type:** {event.inflection_type}\n"
            f"- **Magnitude:** {event.magnitude:.6f}\n"
            f"- **Φ at inflection:** {event.phi_at_inflection:.4f}\n"
            f"- **V-accumulator:** {event.v_accumulator_before:.4f} → {event.v_accumulator_after:.4f}\n"
            f"- **Loop:** {event.loop_index}\n"
            f"- **Topology:** {event.topology_signature}\n"
        )

    def format_specimen(self, specimen) -> str:
        return (
            f"## 🧬 Specimen Classified: {specimen.specimen_class.upper()}\n"
            f"- **ID:** {specimen.specimen_id}\n"
            f"- **Φ-coherence:** {specimen.phi_coherence:.4f}\n"
            f"- **V-accumulator mass:** {specimen.v_accumulator_mass:.4f}\n"
            f"- **FIRE events:** {specimen.fire_event_count}\n"
            f"- **Emergence tick:** {specimen.emergence_tick}\n"
        )

    def format_miracle(self, miracle) -> str:
        return (
            f"## ✨ Training Miracle: {miracle.paradigm.value.upper()}\n"
            f"- **ID:** {miracle.miracle_id}\n"
            f"- **Unaccomplishment:** {miracle.unaccomplishment_density:.2%}\n"
            f"- **Targeting:** {', '.join(miracle.targeted_capabilities)}\n"
            f"- **V-investment:** {miracle.v_accumulator_investment}\n"
            f"- **Estimated loops:** {miracle.estimated_loops}\n"
            f"- **Φ required:** {miracle.phi_required}\n"
            f"- **Strategy:** {miracle.strategy}\n"
        )

    def format_transition(self, transition) -> str:
        return (
            f"## ⚡ Phase Transition: {transition.domain}\n"
            f"- **Unaccomplishment density:** {transition.unaccomplishment_density:.4f}\n"
            f"- **Task count:** {transition.task_count}\n"
            f"- **Threshold:** {transition.threshold}\n"
        )

    def broadcast(self, event_type: str, content: str, metadata: dict = None,
                  targets: list[str] = None) -> BroadcastEntry:
        """Broadcast a reasoning event."""
        entry = BroadcastEntry(
            entry_id=hashlib.sha256(f"{event_type}:{time.time()}".encode()).hexdigest()[:16],
            event_type=event_type,
            content=content,
            metadata=metadata or {},
            timestamp=time.time(),
            broadcast_to=targets or ["github"],
        )
        self.entries.append(entry)

        if "github" in entry.broadcast_to:
            self._push_to_github(entry)
        if "telegram" in entry.broadcast_to:
            self._push_to_telegram(entry)

        return entry

    def _push_to_github(self, entry: BroadcastEntry):
        """Push entry to GitHub runs/live-reasoning via API."""
        if not self.github_token:
            return

        filename = f"{int(time.time())}_{entry.event_type}_{entry.entry_id}.md"
        path = f"{self.runs_dir}/{filename}"
        content_b64 = __import__("base64").b64encode(
            entry.content.encode()
        ).decode()

        try:
            result = subprocess.run([
                "curl", "-s", "-X", "PUT",
                f"https://api.github.com/repos/{self.repo}/contents/{path}",
                "-H", f"Authorization: token {self.github_token}",
                "-H", "Content-Type: application/json",
                "-d", json.dumps({
                    "message": f"live-reasoning: {entry.event_type} @ {entry.entry_id}",
                    "content": content_b64,
                    "branch": self.branch,
                })
            ], capture_output=True, text=True, timeout=10)
        except Exception:
            pass  # Non-blocking — broadcast is best-effort

    def _push_to_telegram(self, entry: BroadcastEntry):
        """Push to Telegram (placeholder — requires bot token)."""
        pass  # Wired through OpenClaw Telegram plugin

    def broadcast_report(self) -> dict:
        return {
            "total_entries": len(self.entries),
            "by_type": {t: sum(1 for e in self.entries if e.event_type == t) for t in set(e.event_type for e in self.entries)},
            "github_pushes": sum(1 for e in self.entries if "github" in e.broadcast_to),
        }


if __name__ == "__main__":
    broadcaster = LiveReasoningBroadcaster()

    # Format examples
    print("=== Broadcast Format Examples ===\n")

    # Simulated FIRE event
    class FakeFire:
        tick = 150; inflection_type = "phase_shift"; magnitude = 0.3421
        phi_at_inflection = 0.88; v_accumulator_before = 0.45; v_accumulator_after = 0.72
        loop_index = 10; topology_signature = "bh_gen10_001"
    print(broadcaster.format_fire_event(FakeFire()))

    # Simulated specimen
    class FakeSpecimen:
        specimen_class = "cryptid"; specimen_id = "abc123"
        phi_coherence = 0.92; v_accumulator_mass = 0.72
        fire_event_count = 3; emergence_tick = 420
    print(broadcaster.format_specimen(FakeSpecimen()))

    print(f"\nBroadcast report: {json.dumps(broadcaster.broadcast_report(), indent=2)}")