"""Prospectively locked, held-out T2 channel audit. See ../preregistration.md."""
from __future__ import annotations

import os
for _key in ("OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "OMP_NUM_THREADS"):
    os.environ[_key] = "1"

import argparse
import hashlib
import importlib.metadata
import json
import platform
import sys
import time
from datetime import datetime, timezone
from pathlib import Path

import numpy as np
from threadpoolctl import threadpool_limits

from vae import train_vae, encode, decode, loss_and_grads, init_params
from linear_gaussian import (train_linear, encode_linear, decode_linear,
                             loss_and_grads_linear, init_linear)

ROOT = Path(__file__).resolve().parent.parent
RESULTS = ROOT / "results"
KINDS = ("A3_tanh_dz4", "linear_dz4")
PROBES = ("linear", "quadratic")


def utc():
    return datetime.now(timezone.utc).isoformat()


def save(path, obj):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(obj, indent=2, allow_nan=False) + "\n", encoding="utf8")


def sources():
    paths = [ROOT / "preregistration.md", ROOT / "requirements.txt"]
    paths += sorted((ROOT / "src").glob("*.py"))
    return {p.relative_to(ROOT).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest()
            for p in paths if p.name != "report.py"}


def lock():
    p = ROOT / "execution_lock.json"
    if p.exists():
        raise RuntimeError("Lock already exists; preserve it.")
    save(p, {"locked_utc": utc(), "registration": "local_pre_execution_not_external",
             "sources_sha256": sources(), "python": sys.version,
             "packages": {n: importlib.metadata.version(n)
                          for n in ("numpy", "threadpoolctl")}})


def verify_lock():
    obj = json.loads((ROOT / "execution_lock.json").read_text(encoding="utf8"))
    if sources() != obj["sources_sha256"]:
        raise RuntimeError("Execution source or preregistration changed after lock")
    return obj


def dataset(i):
    rng = np.random.default_rng(11110000 + i)
    means = rng.normal(size=(4, 8))
    means *= 3.0 / np.linalg.norm(means, axis=1, keepdims=True)
    out = []
    for n in (2000, 1000, 2000):
        y = np.repeat(np.arange(4), n // 4)
        rng.shuffle(y)
        x = means[y] + rng.normal(0.0, 0.3, size=(n, 8))
        out.append((x, y))
    joined = np.concatenate([v[0] for v in out])
    if len(np.unique(joined, axis=0)) != len(joined):
        raise RuntimeError("Duplicated observation across partitions")
    return out


def features(train, test, probe):
    def scale(a, b):
        center, sd = a.mean(0), a.std(0)
        sd = np.maximum(sd, 1e-12)
        return (a - center) / sd, (b - center) / sd
    a, b = scale(train, test)
    if probe == "quadratic":
        ii, jj = np.triu_indices(a.shape[1])
        a = np.column_stack([a, a[:, ii] * a[:, jj]])
        b = np.column_stack([b, b[:, ii] * b[:, jj]])
        a, b = scale(a, b)
    return np.column_stack([np.ones(len(a)), a]), np.column_stack([np.ones(len(b)), b])


def predict(train, y_train, test, probe):
    a, b = features(train, test, probe)
    penalty = np.eye(a.shape[1])
    penalty[0, 0] = 0.0
    weights = np.linalg.solve(a.T @ a + penalty, a.T @ np.eye(4)[y_train])
    return (b @ weights).argmax(1)


def kl_bound(mu, sig):
    return float(np.mean(0.5 * np.sum(mu**2 + sig**2 - 1 - np.log(sig**2), axis=1)))


def fit_one(i, kind, beta, output=None):
    output = RESULTS if output is None else output
    t0 = time.perf_counter()
    (x_fit, _), (x_probe, y_probe), (x_test, y_test) = dataset(i)
    seed = 11120000 + i
    if kind == "A3_tanh_dz4":
        model = train_vae(x_fit, kind, beta, seed)
        enc, dec = encode, decode
    else:
        model = train_linear(x_fit, beta, seed, d_z=4)
        enc, dec = encode_linear, decode_linear
    mu_p, sig_p = enc(model, x_probe)
    mu_t, sig_t = enc(model, x_test)
    if not all(np.isfinite(v).all() for v in (*model.params.values(), mu_p, sig_p, mu_t, sig_t)):
        raise RuntimeError("Non-finite fit")
    # Identical noise realizations across paired architecture/ beta conditions.
    rng = np.random.default_rng(11130000 + i)
    eps_p, eps_t = rng.normal(size=mu_p.shape), rng.normal(size=mu_t.shape)
    z_p, z_t = mu_p + sig_p * eps_p, mu_t + sig_t * eps_t
    channels = {
        "input": (x_probe, x_test), "mean": (mu_p, mu_t),
        "mean_report": (dec(model, mu_p), dec(model, mu_t)),
        "sample": (z_p, z_t), "sample_report": (dec(model, z_p), dec(model, z_t)),
        "prior": (eps_p, eps_t),
    }
    for m in (16, 256):
        e_p, e_t = rng.normal(size=mu_p.shape), rng.normal(size=mu_t.shape)
        zm_p, zm_t = mu_p + sig_p * e_p / np.sqrt(m), mu_t + sig_t * e_t / np.sqrt(m)
        channels[f"average_{m}_report"] = (dec(model, zm_p), dec(model, zm_t))
    shuffled = np.random.default_rng(11150000 + i).permutation(y_probe)
    metrics, predictions = {}, {"label": y_test}
    for probe in PROBES:
        metrics[probe] = {}
        for name, (a, b) in channels.items():
            pred = predict(a, y_probe, b, probe)
            metrics[probe][name] = float(np.mean(pred == y_test))
            predictions[f"{probe}_{name}"] = pred
        a, b = channels["mean_report"]
        pred = predict(a, shuffled, b, probe)
        metrics[probe]["shuffled_report"] = float(np.mean(pred == y_test))
        predictions[f"{probe}_shuffled_report"] = pred
    row = {"replicate": i, "kind": kind, "beta": beta, "model_seed": seed,
           "data_seed": 11110000 + i, "noise_seed": 11130000 + i,
           "kl_upper_nats": kl_bound(mu_t, sig_t), "accuracy": metrics,
           "duration_seconds": time.perf_counter() - t0,
           "max_abs_log_variance": float(np.max(np.abs(np.log(sig_t**2)))),
           "partitions_duplicate_free": True}
    row["pinsker_expected_accuracy_upper"] = min(1.0, .25 + np.sqrt(row["kl_upper_nats"] / 2))
    prefix = f"r{i:02d}_{kind}_b{int(beta)}"
    output.mkdir(parents=True, exist_ok=True)
    np.savez_compressed(output / f"{prefix}_model.npz", **model.params)
    np.savez_compressed(output / f"{prefix}_test.npz", x=x_test, mu=mu_t, sigma=sig_t,
                        **predictions)
    return row


def interval(values):
    a = np.asarray(values, dtype=float)
    rng = np.random.default_rng(11140000)
    boot = a[rng.integers(0, len(a), size=(20000, len(a)))].mean(1)
    return {"mean": float(a.mean()), "low95": float(np.quantile(boot, .025)),
            "high95": float(np.quantile(boot, .975)), "n": len(a)}


def summarize(rows):
    summaries = {}
    for beta, n in ((128, 30), (1, 6)):
        for kind in KINDS:
            rr = sorted([r for r in rows if r["kind"] == kind and r["beta"] == beta],
                        key=lambda r: r["replicate"])
            if len(rr) != n:
                raise RuntimeError("Incomplete design")
            entry = {"kl_upper_nats": interval([r["kl_upper_nats"] for r in rr]),
                     "collapse_count": sum(r["kl_upper_nats"] < .7 for r in rr)}
            for probe in PROBES:
                entry[probe] = {name: interval([r["accuracy"][probe][name] for r in rr])
                                for name in rr[0]["accuracy"][probe]}
                entry[probe]["paired_mean_minus_sample_report"] = interval([
                    r["accuracy"][probe]["mean_report"] - r["accuracy"][probe]["sample_report"]
                    for r in rr])
                for label, report in (("mean_strict_count", "mean_report"),
                                      ("sample_strict_count", "sample_report")):
                    entry[probe][label] = sum(
                        r["kl_upper_nats"] < .7 and r["accuracy"][probe][report] > .55
                        and r["accuracy"][probe]["sample"] < .4
                        and r["accuracy"][probe]["mean"] > .55 for r in rr)
            summaries[f"{kind}_beta{beta}"] = entry
    gates = {"fits_complete_finite_duplicate_free": len(rows) == 72,
             "A3_collapse_at_least_24": summaries["A3_tanh_dz4_beta128"]["collapse_count"] >= 24}
    for kind in KINDS:
        p = summaries[f"{kind}_beta128"]["linear"]
        gates[f"{kind}_input"] = p["input"]["mean"] >= .95
        for channel in ("prior", "shuffled_report"):
            gates[f"{kind}_{channel}"] = .20 <= p[channel]["mean"] <= .30
        gates[f"{kind}_positive"] = summaries[f"{kind}_beta1"]["linear"]["sample_report"]["mean"] >= .55
    a = summaries["A3_tanh_dz4_beta128"]["linear"]
    if not all(gates.values()):
        verdict = "MEASUREMENT_OR_REGIME_FAILURE"
    elif a["sample_report"]["low95"] > .55:
        verdict = "CHANNEL_RETAINS"
    elif (a["paired_mean_minus_sample_report"]["low95"] > .10
          and a["sample_report"]["high95"] < .40 and a["mean_report"]["low95"] > .55):
        verdict = "MEAN_PATH_DEPENDENCE"
    else:
        verdict = "INCONCLUSIVE"
    comparisons = {}
    for probe in PROBES:
        comparisons[probe] = {}
        aa = sorted([r for r in rows if r["kind"] == KINDS[0] and r["beta"] == 128], key=lambda r:r["replicate"])
        bb = sorted([r for r in rows if r["kind"] == KINDS[1] and r["beta"] == 128], key=lambda r:r["replicate"])
        for name in ("mean_report", "sample_report"):
            comparisons[probe][name] = interval([r["accuracy"][probe][name] - s["accuracy"][probe][name]
                                                for r,s in zip(aa,bb)])
    return {"verdict": verdict, "gates": gates, "groups": summaries,
            "A3_minus_linear_paired": comparisons, "bootstrap_seed": 11140000,
            "bootstrap_resamples": 20000, "unit": "independent_dataset_and_initialization"}


def calibration():
    rng = np.random.default_rng(11160000)
    yp = np.tile(np.arange(4), 250)
    yt = np.tile(np.arange(4), 500)
    mp, mt = .001 * np.eye(4)[yp], .001 * np.eye(4)[yt]
    zp, zt = mp + rng.normal(size=mp.shape), mt + rng.normal(size=mt.shape)
    control = {}
    for probe in PROBES:
        clean = float(np.mean(predict(mp/.001, yp, mt/.001, probe) == yt))
        noisy = float(np.mean(predict(zp/.001, yp, zt/.001, probe) == yt))
        assert clean == 1.0 and .20 <= noisy <= .30, (probe, clean, noisy)
        control[probe] = {"noise_free_accuracy": clean, "sampled_accuracy": noisy}
    control["kl_upper_nats"] = kl_bound(mt, np.ones_like(mt))
    assert abs(control["kl_upper_nats"] - 5e-7) < 1e-12
    # Check inherited manual gradients at interior (unclipped) points with fixed noise.
    max_error = 0.0
    xx = rng.normal(size=(7,8))
    for kind in KINDS:
        p = init_params(11160100,8,64,4) if kind == KINDS[0] else init_linear(11160100,8,4)
        def evaluate():
            noise = np.random.default_rng(11160200)
            if kind == KINDS[0]:
                return loss_and_grads(xx,p,128.,"tanh",noise,4)
            return loss_and_grads_linear(xx,p,128.,noise,4)
        _, grads, _ = evaluate()
        for key in p:
            idx = (0,) * p[key].ndim
            old = p[key][idx]
            p[key][idx] = old + 1e-5
            plus = evaluate()[0]
            p[key][idx] = old - 1e-5
            minus = evaluate()[0]
            p[key][idx] = old
            num = (plus-minus)/2e-5
            error = abs(num - grads[key][idx]) / max(1.,abs(num),abs(grads[key][idx]))
            max_error = max(max_error, float(error))
            assert error < 1e-5, (kind,key,error)
    save(ROOT / "calibration.json", {"utc": utc(), "analytic_channel": control,
                                     "gradient_max_scaled_error": max_error, "passed": True})
    print(json.dumps({"calibration": "PASSED", "gradient_max_scaled_error": max_error}), flush=True)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("mode", choices=("calibrate", "lock", "run", "verify", "analyze"))
    args = parser.parse_args()
    with threadpool_limits(limits=1):
        if args.mode == "calibrate":
            calibration(); return
        if args.mode == "lock":
            lock(); return
        execution_lock = verify_lock()
        if args.mode == "analyze":
            rows = [json.loads(p.read_text(encoding="utf8")) for p in sorted(RESULTS.glob("r*_metrics.json"))]
            save(RESULTS / "summary.json", summarize(rows)); return
        if args.mode == "verify":
            folder = RESULTS / "verification"
            row = fit_one(0, KINDS[0], 128, output=folder)
            prefix = "r00_A3_tanh_dz4_b128"
            arrays_checked = 0
            for suffix in ("model", "test"):
                with np.load(RESULTS / f"{prefix}_{suffix}.npz") as original, np.load(folder / f"{prefix}_{suffix}.npz") as repeated:
                    assert original.files == repeated.files
                    for key in original.files:
                        assert np.array_equal(original[key], repeated[key]), key
                        arrays_checked += 1
            old = json.loads((RESULTS / f"{prefix}_metrics.json").read_text(encoding="utf8"))
            assert {k:v for k,v in old.items() if k != "duration_seconds"} == {k:v for k,v in row.items() if k != "duration_seconds"}
            save(RESULTS / "verification_metrics.json", {"passed": True, "utc": utc(),
                 "arrays_bit_identical": arrays_checked, "metrics_identical": True})
            print(json.dumps({"verification":"PASSED","arrays":arrays_checked}),flush=True)
            return
        if (RESULTS / "summary.json").exists():
            raise RuntimeError("Completed run exists; preserve it")
        RESULTS.mkdir(parents=True, exist_ok=True)
        start = time.perf_counter()
        save(RESULTS / "execution.json", {"started_utc": utc(), "execution_lock": execution_lock,
             "platform": platform.platform(), "python": sys.version,
             "packages": {n: importlib.metadata.version(n) for n in ("numpy", "threadpoolctl")}})
        design = [(i,k,128) for i in range(30) for k in KINDS]
        design += [(i,k,1) for i in range(6) for k in KINDS]
        rows = []
        with (RESULTS / "run.log").open("a",encoding="utf8") as logfile:
            for count, (i,kind,beta) in enumerate(design,1):
                dest = RESULTS / f"r{i:02d}_{kind}_b{beta}_metrics.json"
                if dest.exists():
                    row = json.loads(dest.read_text(encoding="utf8"))
                else:
                    row = fit_one(i,kind,beta)
                    save(dest,row)
                rows.append(row)
                text = json.dumps({"completed": count, "total": len(design),
                                   "replicate":i,"kind":kind,"beta":beta,
                                   "elapsed_seconds":round(time.perf_counter()-start,1)})
                print(text,flush=True); logfile.write(text+"\n"); logfile.flush()
        summary = summarize(rows)
        summary["completed_utc"] = utc()
        summary["duration_seconds"] = time.perf_counter()-start
        save(RESULTS / "summary.json",summary)
        save(RESULTS / "all_metrics.json",rows)
        print(json.dumps({"verdict":summary["verdict"],"gates":summary["gates"]}),flush=True)


if __name__ == "__main__":
    main()
