"""Validate the explicitly scoped research release, not production maturity."""
from pathlib import Path
import argparse,csv,hashlib,json,platform,re,subprocess,sys
ROOT=Path(__file__).resolve().parents[1]
sys.path.insert(0,str(ROOT))
import numpy as np


def load(name):return json.loads((ROOT/name).read_text())


def validate(output="validation_reproduced.json",require_replay=False):
    gates=[]
    def gate(name,passed,details):
        gates.append({"name":name,"passed":bool(passed),"details":details})
    required=["README.md","LICENSE","CITATION.cff","MANUSCRIPT.md","AUREOLE_R_v2.0.0_Research_Release.pdf",
              "STATUS.json","CLAIMS.json","AI_AGENT_INDEX.json","MODEL_CARD.md","models/visibility_prior.npz",
              "docs/ESTIMATOR_CONTRACT.md","docs/RELEASE_SCOPE.md","docs/RESIDUAL_THEORY.md",
              "experiments.json","experiments_followup.json","scripts/demo.py","scripts/publish_hf.py",
              "results/rendering_report.json","results/followup_report.json","results/training.json"]
    missing=[p for p in required if not (ROOT/p).is_file()]
    gate("required_release_files",not missing,{"missing":missing})
    counts=[]
    for start,expected in [("tests",28),("legacy/code",14)]:
        result=subprocess.run([sys.executable,"-m","unittest","discover","-s",start,"-p","test_*.py","-v"],cwd=ROOT,capture_output=True,text=True)
        match=re.search(r"Ran (\d+) tests?",result.stderr)
        count=int(match.group(1)) if match else 0;counts.append(count)
        gate(f"executable_tests_{start}",result.returncode==0 and count==expected,{"exit_code":result.returncode,"tests":count,"expected_tests":expected})
    training=load("results/training.json");a=load("results/rendering_report.json");b=load("results/followup_report.json")
    train=set(training["training_scene_ids"]);val=set(training["validation_scene_ids"]);test=set(training["test_scene_ids"])
    follow=set(b["protocol"]["scene_ids"])
    gate("independent_scene_splits",not(train&val or train&test or val&test or follow&(train|val|test)),
         {"training_scenes":len(train),"validation_scenes":len(val),"first_test_scenes":len(test),"followup_scenes":len(follow)})
    from aureole.renderer import VisibilityPrior,Scene,receiver_grid,light_grid
    prior=VisibilityPrior(ROOT/"models/visibility_prior.npz")
    pred=prior(Scene.create(900).features(receiver_grid(4,4)[:,None,:],light_grid(2)[None,:,:]))
    gate("portable_model",np.isfinite(pred).all() and ((pred>=0)&(pred<=1)).all() and training["numpy_torch_max_abs_error"]<1e-5,
         {"parameters":training["parameters"],"numpy_torch_max_abs_error":training["numpy_torch_max_abs_error"],"test_model_sha256":hashlib.sha256((ROOT/"models/visibility_prior.npz").read_bytes()).hexdigest()})
    for prefix,report in [("rendering",a),("followup",b)]:
        rows=list(csv.DictReader((ROOT/f"results/{prefix}_raw.csv").open()))
        finite=all(np.isfinite(float(r[k])) for r in rows for k in ["mse","conditional_expected_mse","mean_error","negative_channel_fraction"])
        total=sum(int(r["rays"]) for r in rows)
        ray_budget=np.prod(report["protocol"]["viewport"])*report["protocol"]["rays_per_receiver_per_frame"]
        ray_match=all(int(r["rays"])==ray_budget for r in rows)
        errors=[]
        for item in report["summary"]:
            raw=[float(r["conditional_expected_mse"]) for r in rows if r["phase"]==item["phase"] and r["method"]==item["method"]]
            errors.append(abs(np.mean(raw)-item["expected_mse"]))
        gate(f"raw_data_consistency_{prefix}",finite and ray_match and len(rows)==report["record_count"] and total==report["total_physical_ray_calls"] and max(errors)<1e-12,
             {"rows":len(rows),"rays":total,"equal_per_row_ray_budget":int(ray_budget),"max_summary_error":float(max(errors))})
    original_failure=next(c for c in a["comparisons"] if c["phase"]=="hidden_change" and c["contender"]=="world_active_cv" and c["baseline"]=="world_cv")
    neutral_prior=next(c for c in a["comparisons"] if c["phase"]=="revisit" and c["baseline"]=="constant_world_cv")
    gate("negative_and_inconclusive_results_retained",original_failure["relative_expected_mse_reduction"]<0 and neutral_prior["scene_bootstrap_95"][0]<0<neutral_prior["scene_bootstrap_95"][1],
         {"active_hidden_change_reduction":original_failure["relative_expected_mse_reduction"],"neural_ablation_interval":neutral_prior["scene_bootstrap_95"]})
    if require_replay:
        errors=[]
        for prefix,reference in [("rendering",a),("followup",b)]:
            replay=load(f"reproduced_results/{prefix}_report.json")
            for original,rerun in zip(reference["summary"],replay["summary"],strict=True):
                for key in ("expected_mse","observed_mse","negative_channel_fraction"):
                    errors.append(abs(original[key]-rerun[key]))
        gate("deterministic_full_replay",max(errors)<1e-12,{"max_nontiming_metric_difference":float(max(errors)),"timings_excluded":True})
    else:
        gate("recorded_replay_evidence",(ROOT/"results/replay_validation.json").exists(),{"live_replay":"Use --require-replay after running both scripts with default output paths"})
    install=load("results/installation_validation.json")
    gate("recorded_installation_check",install.get("installation_import_passed") is True,{"version":install.get("version"),"meaning":"Recorded clean-target install/import; not a platform compatibility matrix"})
    demo=load("results/demo/demo.json")
    gate("recorded_physical_demo",np.isfinite(demo["final_mse"]) and demo["frames"]==24 and (ROOT/"results/demo/demo.png").exists(),
         {"frames":demo["frames"],"rays":demo["rays"],"mse":demo["final_mse"]})
    status=load("STATUS.json")
    gate("scope_and_claims_agree",status["verified"]["gpu_benchmarks"]==0 and status["verified"]["full_sr_rr_fg_experiments"]==0 and status["verified"]["new_contract_tests"]==counts[0] and status["overall_maturity_estimate_percent"]<100,
         {"production_gates_open":status["production_gates_open"],"research_maturity_is_estimated_not_measured":True})
    report={"version":"2.0.0","scope":"Executable finite-light CPU research reference. This checklist does not measure general research maturity or production readiness.",
            "passed":all(g["passed"] for g in gates),"gates_passed":sum(g["passed"] for g in gates),"gates_total":len(gates),
            "gates":gates,"environment":{"python":platform.python_version(),"numpy":np.__version__},
            "not_validated":["Windows launcher execution","Hugging Face upload execution","CUDA or GPU performance","Full SR/RR/FG integration","Independent replication"]}
    path=ROOT/output;path.parent.mkdir(parents=True,exist_ok=True);path.write_text(json.dumps(report,indent=2)+"\n")
    print(json.dumps(report,indent=2))
    return 0 if report["passed"] else 1

if __name__=="__main__":
    parser=argparse.ArgumentParser();parser.add_argument("--output",default="validation_reproduced.json")
    parser.add_argument("--require-replay",action="store_true")
    args=parser.parse_args();raise SystemExit(validate(args.output,args.require_replay))