from __future__ import annotations

import argparse
import json
import sys
from dataclasses import asdict, dataclass
from pathlib import Path
from typing import Any

ROOT_DIR = Path(__file__).resolve().parent.parent
if str(ROOT_DIR) not in sys.path:
    sys.path.insert(0, str(ROOT_DIR))

from scripts.next_deployment_step import (
    LIVE_PROOF,
    LOCAL_REPORT,
    SITE_REPORT,
    WORKER_REPORT,
    choose_next_step,
    deployment_urls_look_real,
    load_json,
    local_ready,
)


@dataclass
class ReportStatus:
    path: str
    exists: bool
    valid_json: bool
    summary: str


@dataclass
class DeploymentStatus:
    ready_for_live_urls: bool
    live_urls_look_real: bool
    live_complete: bool
    reports_are_real_live_evidence: bool
    local_report: ReportStatus
    site_report: ReportStatus
    worker_report: ReportStatus
    live_proof: ReportStatus
    missing_site_checks: list[str]
    missing_worker_checks: list[str]
    next_status: str
    next_title: str
    next_detail: str
    next_command: str


def _report_status(path: Path) -> ReportStatus:
    payload = load_json(path)
    if payload is None:
        return ReportStatus(str(path), path.exists(), False, "missing or invalid JSON")
    return ReportStatus(str(path), True, True, summarize_payload(path, payload))


def _list_checks_ok(payload: Any, names: set[str]) -> bool:
    if not isinstance(payload, list):
        return False
    checks = {str(item.get("name", "")): bool(item.get("ok")) for item in payload if isinstance(item, dict)}
    return all(checks.get(name) is True for name in names)


def _missing_checks(payload: Any, names: set[str]) -> list[str]:
    if not isinstance(payload, list):
        return sorted(names)
    checks = {str(item.get("name", "")): bool(item.get("ok")) for item in payload if isinstance(item, dict)}
    return sorted(name for name in names if checks.get(name) is not True)


def _looks_like_test_artifact(payload: Any) -> bool:
    if not isinstance(payload, dict):
        return False
    text = json.dumps(payload, ensure_ascii=False).lower()
    return "pytest-" in text or "your-space.hf.space" in text or "your-vercel-app.vercel.app" in text


def _url_evidence_matches(live_payload: Any, worker_url: str | None, vercel_origin: str | None) -> bool:
    if not isinstance(live_payload, dict):
        return False
    proof_worker = str(live_payload.get("workerUrl") or "").rstrip("/")
    proof_origin = str(live_payload.get("origin") or "").rstrip("/")
    expected_worker = (worker_url or proof_worker).rstrip("/")
    expected_origin = (vercel_origin or proof_origin).rstrip("/")
    if not deployment_urls_look_real(expected_worker, expected_origin):
        return False
    return proof_worker == expected_worker and proof_origin == expected_origin


def summarize_payload(path: Path, payload: Any) -> str:
    if isinstance(payload, dict):
        if "ready" in payload or "complete" in payload:
            return f"ready={payload.get('ready')} complete={payload.get('complete')}"
        if "counts" in payload:
            return f"counts={payload.get('counts')}"
        return f"object keys={','.join(sorted(str(key) for key in payload.keys())[:6])}"
    if isinstance(payload, list):
        passed = sum(1 for item in payload if isinstance(item, dict) and item.get("ok") is True)
        failed = sum(1 for item in payload if isinstance(item, dict) and item.get("ok") is False)
        return f"checks={len(payload)} pass={passed} fail={failed}"
    return type(payload).__name__


def build_status(
    worker_url: str | None = None,
    vercel_origin: str | None = None,
    code: str = "1234",
    local_report: Path = LOCAL_REPORT,
    site_report: Path = SITE_REPORT,
    worker_report: Path = WORKER_REPORT,
    live_proof: Path = LIVE_PROOF,
) -> DeploymentStatus:
    site_required = {
        "site login",
        "site platform vercel",
        "site worker configured",
        "site large PDF ready",
        "site production worker ready",
        "site hosted limits documented",
        "site recommended stack documented",
        "site direct cloud fallback disabled",
        "site worker diagnostics endpoint",
        "site worker reachable from vercel",
        "site worker CORS ready",
    }
    worker_required = {
        "recommended stack documented",
        "smoke upload accepted",
        "smoke job complete",
        "smoke usable text",
        "smoke audio url",
        "smoke download url",
        "smoke audio bytes",
        "smoke audio file signature",
        "smoke download bytes",
        "smoke download file signature",
        "scanned smoke upload accepted",
        "scanned smoke job complete",
        "scanned smoke usable text",
        "scanned smoke OCR extraction",
        "scanned smoke audio url",
        "scanned smoke download url",
        "scanned smoke audio bytes",
        "scanned smoke audio file signature",
        "scanned smoke download bytes",
        "scanned smoke download file signature",
    }
    live_payload = load_json(live_proof)
    site_payload = load_json(site_report)
    worker_payload = load_json(worker_report)
    missing_site_checks = _missing_checks(site_payload, site_required)
    missing_worker_checks = _missing_checks(worker_payload, worker_required)
    live_complete = isinstance(live_payload, dict) and bool(live_payload.get("complete"))
    live_urls_look_real = deployment_urls_look_real(worker_url, vercel_origin)
    reports_are_real_live_evidence = bool(
        live_complete
        and not missing_site_checks
        and not missing_worker_checks
        and not _looks_like_test_artifact(live_payload)
        and _url_evidence_matches(live_payload, worker_url, vercel_origin)
    )
    next_step = choose_next_step(
        worker_url=worker_url,
        vercel_origin=vercel_origin,
        code=code,
        local_report=local_report,
        site_report=site_report,
        worker_report=worker_report,
        live_proof=live_proof,
    )
    if live_complete and not reports_are_real_live_evidence:
        next_status = "live-proof"
        next_title = "Re-run live proof against real deployed URLs"
        next_detail = (
            "A complete live proof file exists, but it does not look like trustworthy live evidence. "
            "Re-run the proof after replacing placeholder/test URLs with the real Hugging Face worker and Vercel site."
        )
        next_command = (
            f"python scripts\\prove_live_deployment.py {worker_url or 'https://your-space.hf.space'} "
            f"--origin {vercel_origin or 'https://your-vercel-app.vercel.app'} --code {code} "
            "--smoke-ocr-engine arabic "
            "--check-hf-metadata --hf-metadata-report outputs\\hf-model-metadata.md "
            "--proof-out outputs\\live-deployment-proof.json"
        )
    else:
        next_status = next_step.status
        next_title = next_step.title
        next_detail = next_step.detail
        next_command = next_step.command
    return DeploymentStatus(
        ready_for_live_urls=local_ready(local_report) and live_urls_look_real,
        live_urls_look_real=live_urls_look_real,
        live_complete=live_complete,
        reports_are_real_live_evidence=reports_are_real_live_evidence,
        local_report=_report_status(local_report),
        site_report=_report_status(site_report),
        worker_report=_report_status(worker_report),
        live_proof=_report_status(live_proof),
        missing_site_checks=missing_site_checks,
        missing_worker_checks=missing_worker_checks,
        next_status=next_status,
        next_title=next_title,
        next_detail=next_detail,
        next_command=next_command,
    )


def print_status(status: DeploymentStatus) -> None:
    print(f"Ready for live URLs: {status.ready_for_live_urls}")
    print(f"Live URLs look real: {status.live_urls_look_real}")
    print(f"Live proof complete: {status.live_complete}")
    print(f"Reports are real live evidence: {status.reports_are_real_live_evidence}")
    print()
    for label, report in [
        ("Local", status.local_report),
        ("Site", status.site_report),
        ("Worker", status.worker_report),
        ("Live proof", status.live_proof),
    ]:
        print(f"{label}: {report.summary} ({report.path})")
    if status.missing_site_checks:
        print()
        print("Missing site proof checks:")
        for name in status.missing_site_checks:
            print(f"- {name}")
    if status.missing_worker_checks:
        print()
        print("Missing worker proof checks:")
        for name in status.missing_worker_checks:
            print(f"- {name}")
    print()
    print(status.next_title)
    print(status.next_detail)
    print()
    print(status.next_command)


def main() -> None:
    parser = argparse.ArgumentParser(description="Show the current deployment proof status and next command.")
    parser.add_argument("--worker-url", help="Live worker URL, for example https://your-space.hf.space")
    parser.add_argument("--origin", help="Live Vercel origin, for example https://your-app.vercel.app")
    parser.add_argument("--code", default="1234", help="Access code for live verification.")
    parser.add_argument("--json", action="store_true", help="Print JSON.")
    args = parser.parse_args()

    status = build_status(worker_url=args.worker_url, vercel_origin=args.origin, code=args.code)
    if args.json:
        print(json.dumps(asdict(status), ensure_ascii=False, indent=2))
    else:
        print_status(status)


if __name__ == "__main__":
    main()