#!/usr/bin/env python3
"""Quick verification of all harness components."""

import os
import sys
import time
from pathlib import Path

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

ENV_FILE = Path(__file__).parent / ".env"
if ENV_FILE.exists():
    with open(ENV_FILE) as f:
        for line in f:
            line = line.strip()
            if line and "=" in line and not line.startswith("#"):
                key, val = line.split("=", 1)
                os.environ.setdefault(key, val)


def check_api():
    """Check API connectivity."""
    from core.zai_client import ZAiClient

    api_key = os.environ.get("ZAI_API_KEY")
    if not api_key:
        return False, "ZAI_API_KEY not set"

    try:
        with ZAiClient(api_key, timeout=10.0) as client:
            r = client.chat_completion(
                model="glm-4.7-flash",
                messages=[{"role": "user", "content": "ping"}],
                max_tokens=10,
            )
            return True, f"OK - {r.model}"
    except Exception as e:
        return False, str(e)


def check_thinking_modes():
    """Test thinking on/off."""
    from core.zai_client import ZAiClient

    api_key = os.environ.get("ZAI_API_KEY")
    results = []

    with ZAiClient(api_key, timeout=30.0) as client:
        for mode in ["disabled", "enabled"]:
            try:
                r = client.chat_completion(
                    model="glm-4.7-flash",
                    messages=[{"role": "user", "content": "Say OK"}],
                    thinking={"type": mode},
                    max_tokens=20,
                )
                has_reasoning = (
                    r.reasoning_content is not None and len(r.reasoning_content) > 0
                )
                results.append((mode, "OK", has_reasoning))
            except Exception as e:
                results.append((mode, str(e), False))
            time.sleep(1)

    return results


def check_harness():
    """Check harness imports."""
    try:
        from core.salience import SalienceEngine
        from core.blackboard import Blackboard
        from core.scheduler import Scheduler
        from core.model_pool import MODEL_POOL
        from agents.router import Router
        from agents.tlp import TLPGateLoop
        from verifiers.consensus import Verifier

        return True, f"OK - {len(MODEL_POOL)} model slots"
    except Exception as e:
        return False, str(e)


def main():
    print("=" * 50)
    print("  SAL-v4 Harness Health Check")
    print("=" * 50 + "\n")

    print("[1] API Connectivity")
    ok, msg = check_api()
    print(f"    {'OK' if ok else 'FAIL'}: {msg}")

    print("\n[2] Harness Modules")
    ok, msg = check_harness()
    print(f"    {'OK' if ok else 'FAIL'}: {msg}")

    print("\n[3] Thinking Modes")
    results = check_thinking_modes()
    for mode, status, has_reasoning in results:
        reasoning_str = f"reasoning={'YES' if has_reasoning else 'NO'}"
        print(f"    {mode}: {status} ({reasoning_str})")

    print("\n" + "=" * 50)
    print("  Health Check Complete")
    print("=" * 50)


if __name__ == "__main__":
    main()