"""Shared test harness for node-level tests."""

import asyncio
import json
import sys
import time
from dataclasses import dataclass, field
from pathlib import Path

# Add parent to path so we can import agent
sys.path.insert(0, str(Path(__file__).parent.parent))

from agent.types import Envelope, Command, InputAnalysis, ThoughtResult


class HudCapture:
    """Mock send_hud that captures all HUD events for inspection."""
    def __init__(self):
        self.events: list[dict] = []

    async def __call__(self, data: dict):
        self.events.append(data)

    def find(self, event: str) -> list[dict]:
        return [e for e in self.events if e.get("event") == event]

    def has(self, event: str) -> bool:
        return any(e.get("event") == event for e in self.events)

    def last(self) -> dict:
        return self.events[-1] if self.events else {}

    def clear(self):
        self.events.clear()


class MockWebSocket:
    """Mock WebSocket that captures sent messages."""
    def __init__(self):
        self.sent: list[str] = []
        self.readyState = 1

    async def send_text(self, text: str):
        self.sent.append(text)

    def get_messages(self) -> list[dict]:
        return [json.loads(s) for s in self.sent]

    def get_deltas(self) -> str:
        """Reconstruct streamed text from delta messages."""
        return "".join(
            json.loads(s).get("content", "")
            for s in self.sent
            if '"type": "delta"' in s or '"type":"delta"' in s
        )


def make_envelope(text: str, user_id: str = "bob") -> Envelope:
    return Envelope(text=text, user_id=user_id, session_id="test",
                    timestamp=time.strftime("%Y-%m-%d %H:%M:%S"))


def make_command(intent: str = "request", topic: str = "", text: str = "",
                 complexity: str = "simple", tone: str = "casual",
                 language: str = "en", who: str = "bob") -> Command:
    return Command(
        analysis=InputAnalysis(
            who=who, language=language, intent=intent,
            topic=topic, tone=tone, complexity=complexity,
        ),
        source_text=text or topic,
    )


def make_history(messages: list[tuple[str, str]] = None) -> list[dict]:
    """Create history from (role, content) tuples."""
    if not messages:
        return []
    return [{"role": r, "content": c} for r, c in messages]


@dataclass
class NodeTestResult:
    name: str
    passed: bool
    detail: str = ""
    elapsed_ms: int = 0


def run_async(coro):
    """Run an async function synchronously."""
    return asyncio.get_event_loop().run_until_complete(coro)


class NodeTestRunner:
    """Collects and runs node-level tests."""
    def __init__(self):
        self.results: list[NodeTestResult] = []

    def test(self, name: str, coro):
        """Run a single async test, catch and record result."""
        t0 = time.time()
        try:
            run_async(coro)
            elapsed = int((time.time() - t0) * 1000)
            self.results.append(NodeTestResult(name=name, passed=True, elapsed_ms=elapsed))
            print(f"  OK  {name} ({elapsed}ms)")
        except AssertionError as e:
            elapsed = int((time.time() - t0) * 1000)
            self.results.append(NodeTestResult(name=name, passed=False,
                                               detail=str(e), elapsed_ms=elapsed))
            print(f"  FAIL {name} ({elapsed}ms)")
            print(f"    {e}")
        except Exception as e:
            elapsed = int((time.time() - t0) * 1000)
            self.results.append(NodeTestResult(name=name, passed=False,
                                               detail=f"ERROR: {e}", elapsed_ms=elapsed))
            print(f"  ERR  {name} ({elapsed}ms)")
            print(f"    {e}")

    def summary(self) -> tuple[int, int]:
        passed = sum(1 for r in self.results if r.passed)
        failed = len(self.results) - passed
        return passed, failed