#!/usr/bin/env python3
from __future__ import annotations

import argparse
import hashlib
import json
from pathlib import Path
import re
import subprocess
import sys

ROOT = Path(__file__).resolve().parents[1]
DS1 = {101,106,108,109,112,114,115,116,118,119,122,124,201,203,205,207,208,209,215,220,223,230}
DS2 = {100,103,105,111,113,117,121,123,200,202,210,212,213,214,219,221,222,228,231,232,233,234}


def check(condition: bool, message: str, failures: list[str]) -> None:
    if not condition:
        failures.append(message)


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--upstream", type=Path, required=True)
    args = parser.parse_args()
    failures: list[str] = []
    task_path = ROOT / "sforge" / "mitbih_interpatient_arrhythmia.json"
    check(task_path.is_file(), "generated task JSON missing", failures)
    task = json.loads(task_path.read_text(encoding="utf-8"))
    expected_top = {"task_id","name","base_image","platform","cwd","submit_paths","submit_exclude","internet","game_mode","work","judge"}
    check(set(task) == expected_top, "unexpected or missing top-level task fields", failures)
    check(task["task_id"] == "mitbih_interpatient_arrhythmia", "task_id mismatch", failures)
    check(task["internet"] is False, "runtime internet must be disabled", failures)
    check(task["judge"]["parser"] == "structured_json", "parser mismatch", failures)
    check(task["judge"]["selection"] == "valid_then_score", "selection mismatch", failures)
    check(not DS1 & DS2 and len(DS1 | DS2) == 44, "DS1/DS2 record freeze invalid", failures)
    check({102,104,107,217}.isdisjoint(DS1 | DS2), "paced record leaked into split", failures)

    sys.path.insert(0, str(args.upstream))
    try:
        from sforge.harness.benchmark import load_benchmark
        from sforge.harness.task_spec import make_task_spec
        from sforge.harness.log_parsers.structured_json import parse_structured_json
        benchmark = load_benchmark(ROOT / "sforge")
        spec = make_task_spec(task_path, benchmark)
        check(spec.task_id == task["task_id"], "upstream task loader mismatch", failures)
        probe = '>>>>> Start Structured Result\n{"valid":true,"score":12.5}\n>>>>> End Structured Result\n'
        check(parse_structured_json(probe).get("score") == 12.5, "structured parser round-trip failed", failures)
    except Exception as exc:
        failures.append(f"upstream SForge compatibility failed: {type(exc).__name__}: {exc}")

    result = subprocess.run(
        [sys.executable, str(ROOT / "task_repo" / "solution.py"), "--self-test"],
        capture_output=True, text=True,
    )
    check(result.returncode == 0, f"baseline self-test failed: {result.stderr}", failures)
    forbidden = []
    for path in ROOT.rglob("*"):
        if path.is_file() and any(part in {".git", "__pycache__"} for part in path.parts):
            continue
        if path.name in {".DS_Store"} or path.suffix in {".part", ".tmp", ".pyc"}:
            forbidden.append(str(path.relative_to(ROOT)))
    check(not forbidden, f"forbidden files: {forbidden}", failures)
    excluded_scan = {Path(__file__).resolve(), (ROOT / "validation_report.json").resolve()}
    text = "\n".join(
        p.read_text(encoding="utf-8", errors="ignore")
        for p in ROOT.rglob("*")
        if p.is_file() and p.stat().st_size < 2_000_000 and p.resolve() not in excluded_scan
    )
    secret_like = re.search(r"sk-[A-Za-z0-9_-]{20,}|-----BEGIN (?:RSA |EC )?PRIVATE KEY-----", text)
    check(secret_like is None, "possible secret material found", failures)
    host_path = re.escape(str(ROOT.parent.parent.parent))
    check(re.search(host_path, text) is None, "absolute host path leaked", failures)

    report = {
        "status": "PASS" if not failures else "FAIL",
        "checks": {
            "sforge_schema": "PASS" if not any("SForge" in f or "task" in f for f in failures) else "FAIL",
            "patient_disjoint_split": "PASS" if not any("split" in f or "paced" in f for f in failures) else "FAIL",
            "baseline_self_test": "PASS" if result.returncode == 0 else "FAIL",
            "package_hygiene": "PASS" if not forbidden else "FAIL"
        },
        "failures": failures
    }
    (ROOT / "validation_report.json").write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
    print(json.dumps(report, indent=2))
    return 1 if failures else 0


if __name__ == "__main__":
    raise SystemExit(main())