"""Deterministic model-vs-execution diagnostic; no sampled TV estimators."""
from __future__ import annotations

import argparse
import json
import math
import time
from fractions import Fraction
from pathlib import Path

import numpy as np
from scipy.stats import binom


def binomial_tv(n: int, p: float, q: float) -> float:
    """Exact finite distribution identity evaluated by double-precision CDFs.

    The likelihood ratio is monotone; CDF difference at its crossing gives TV.
    Neighbor candidates protect against floating-point rounding at a tie.
    This is not an interval-arithmetic certificate.
    """
    if p == q or n == 0:
        return 0.0
    p, q = sorted((p, q))
    difference = q - p
    log_yes = math.log1p(difference / p)
    log_no = math.log1p(-difference / (1 - p))
    slope = log_yes - log_no
    crossing = -n * log_no / slope
    k = math.floor(crossing)
    candidates = np.array([max(-1, min(n, k + d)) for d in (-1, 0, 1)])
    return float(np.max(binom.cdf(candidates, n, p) - binom.cdf(candidates, n, q)))


def kl_teacher_to_mixture(n, tau, w, delta, block_size=65536):
    """Sum all n+1 teacher count atoms; no intentional tail truncation."""
    total = 0.0
    mass = 0.0
    terms_abs = 0.0
    log_yes = math.log1p(delta / tau)
    log_no = math.log1p(-delta / (1 - tau))
    for start in range(0, n + 1, block_size):
        k = np.arange(start, min(start + block_size, n + 1))
        prob = binom.pmf(k, n, tau)
        log_lr = k * log_yes + (n - k) * log_no
        log_mix_lr = np.logaddexp(math.log1p(-w), math.log(w) + log_lr)
        terms = -prob * log_mix_lr
        total += float(np.sum(terms, dtype=np.float64))
        terms_abs += float(np.sum(abs(terms), dtype=np.float64))
        mass += float(np.sum(prob, dtype=np.float64))
    residual = abs(mass - 1)
    if residual > 2e-8 or total < -1e-10 or total > -math.log1p(-w) + 1e-8:
        raise ArithmeticError((n, total, residual))
    return {"kl": total, "teacher_mass_residual": residual,
            "absolute_summands": terms_abs, "evaluated_atoms": n + 1}


def validate():
    worst_cdf = 0.0
    cases = 0
    for n in (1, 2, 4, 16, 64, 257):
        for p, q in ((.25,.5),(.25,.28125),(.25,.250001),(.1,.8)):
            k = np.arange(n + 1)
            brute = .5 * np.sum(abs(binom.pmf(k,n,p) - binom.pmf(k,n,q)))
            error = abs(binomial_tv(n,p,q) - brute)
            worst_cdf = max(worst_cdf, error)
            assert error < 2e-12, (n,p,q,error)
            cases += 1
    # Independent exact-rational small-count KL computation.
    worst_kl = 0.0
    for n in range(1, 9):
        tau, w, delta = Fraction(1,4), Fraction(1,8), Fraction(1,4)
        expected = 0.0
        for k in range(n + 1):
            p = Fraction(math.comb(n,k)) * tau**k * (1-tau)**(n-k)
            r = (1-w)*p + w*math.comb(n,k)*(tau+delta)**k*(1-tau-delta)**(n-k)
            expected += float(p) * math.log(float(p/r))
        observed = kl_teacher_to_mixture(n,float(tau),float(w),float(delta))["kl"]
        worst_kl = max(worst_kl, abs(expected-observed))
    assert worst_kl < 2e-12
    return {"status":"PASS", "cdf_vs_pmf_cases":cases,
            "cdf_vs_pmf_max_error":worst_cdf,
            "rational_mass_kl_cases":8, "rational_mass_kl_max_error":worst_kl}


def run(config):
    started = time.monotonic()
    validation = validate()
    records = []
    for exponent in config["exponents"]:
        n = 2**exponent
        scale = (n/config["reference_n"])**(-config["decay_exponent"])
        tau = config["tau"]
        w, delta = config["w0"]*scale, config["delta0"]*scale
        stats = kl_teacher_to_mixture(n,tau,w,delta,config["block_size"])
        records.append({"n":n,"tau":tau,"w":w,"delta":delta,
            "kl":stats["kl"],"kl_upper_bound":-math.log1p(-w),
            "model_tv":w*binomial_tv(n,tau,tau+delta),
            "execution_tv":binomial_tv(n,tau,tau+w*delta),
            "head_tv_upper_bound":delta,
            "execution_hoeffding_lower_bound":max(0.0,1-2*math.exp(-n*(w*delta)**2/2)),
            "teacher_mass_residual":stats["teacher_mass_residual"],
            "evaluated_atoms":stats["evaluated_atoms"]})
        print(f"E1 n={n} KL={stats['kl']:.6g} outputTV={records[-1]['execution_tv']:.6g}",flush=True)
    return {"experiment":"e1_model_execution","validation":validation,
        "records":records,"runtime_seconds":time.monotonic()-started,
        "metadata":{"method":"Full finite sums for KL; monotone-likelihood-ratio binomial CDF identity for TV",
                    "error_accounting":"No intentional truncation. Double precision, not rigorous interval bounds; full teacher mass residual recorded.",
                    "policy":"all A, then all B; fixed schedule, not all-policy optimum",
                    "full_tv_justification":"Both laws have independent fair A and iid mismatches; count is sufficient for their likelihood ratio.",
                    "head_error":"delta is a uniform upper bound, not measured worst-case equality"}}


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", type=Path, required=True)
    parser.add_argument("--output", type=Path, required=True)
    args = parser.parse_args()
    result = run(json.loads(args.config.read_text())["e1"])
    args.output.parent.mkdir(parents=True, exist_ok=True)
    args.output.write_text(json.dumps(result, indent=2, allow_nan=False)+"\n")