#!/usr/bin/env python3
"""Exact full-output TV benchmarks for frozen fair-pair exchangeable oracles.

Only Python's standard library is required.  All probabilities and reported
distance comparisons use Fraction; floats are for presentation and timing.
See schedule_math.md for the symmetry and full-output-TV justification.
"""

from __future__ import annotations

import argparse
from collections import defaultdict
from fractions import Fraction
from functools import lru_cache
import hashlib
from itertools import permutations, product
import json
import math
from pathlib import Path
import sys
import time


def shown(value):
    value = Fraction(value)
    return {"rational": str(value), "float": float(value)}


def exact(value):
    if isinstance(value, dict):
        return Fraction(value["rational"])
    return Fraction(value)


def sha256(path):
    return hashlib.sha256(Path(path).read_bytes()).hexdigest()


def compositions(n, parts):
    """All ordered weak compositions, in lexicographic order."""
    if parts == 1:
        yield (n,)
        return
    for first in range(n + 1):
        for rest in compositions(n - first, parts - 1):
            yield (first,) + rest


def floor_root_power(n, exponent, root):
    """floor(n**(exponent/root)), by exact integer inequalities."""
    if not 0 <= exponent <= root or root < 1 or n < 1:
        raise ValueError("Invalid integer-root arguments")
    target = n**exponent
    lo, hi = 0, n + 1
    while hi - lo > 1:
        middle = (lo + hi) // 2
        if middle**root <= target:
            lo = middle
        else:
            hi = middle
    if not lo**root <= target < (lo + 1)**root:
        raise AssertionError("Integer root invariant failed")
    return lo


def geometric_batches(n, r):
    cumulative = [0] + [floor_root_power(n, j, r) for j in range(1, r)] + [n]
    return tuple(b - a for a, b in zip(cumulative, cumulative[1:]))


def equal_batches(n, r):
    cumulative = [j * n // r for j in range(r + 1)]
    return tuple(b - a for a, b in zip(cumulative, cumulative[1:]))


class ExactFairOracle:
    def __init__(self, witness):
        self.n = int(witness["n"])
        self.tau = exact(witness["tau"])
        self.weights = tuple(map(exact, witness["weights"]))
        self.probabilities = tuple(map(exact, witness["probabilities"]))
        if self.n < 1 or not 0 < self.tau < 1:
            raise ValueError("Need positive n and a positive teacher")
        if len(self.weights) != len(self.probabilities) or not self.weights:
            raise ValueError("Mismatching or empty mixture arrays")
        if sum(self.weights) != 1 or any(w < 0 for w in self.weights):
            raise ValueError("Weights must be nonnegative and sum exactly to one")
        if any(not 0 < p < 1 for p in self.probabilities):
            raise ValueError("Every component must be strictly positive")
        self.predictive = lru_cache(None)(self._predictive)
        self.binomial = lru_cache(None)(self._binomial)
        self.teacher_binomial = lru_cache(None)(lambda size: self.binomial(size, self.tau))
        self.evaluate = lru_cache(None)(self._evaluate)

    def _predictive(self, completed, mismatches):
        likelihood = tuple(w * p**mismatches * (1 - p)**(completed - mismatches)
                           for w, p in zip(self.weights, self.probabilities))
        return sum(q * p for q, p in zip(likelihood, self.probabilities)) / sum(likelihood)

    @staticmethod
    def _binomial(size, rate):
        return tuple(Fraction(math.comb(size, m)) * rate**m * (1 - rate)**(size - m)
                     for m in range(size + 1))

    def _evaluate(self, batches):
        """TV on the joint vector of mismatch counts, not just its sum."""
        if sum(batches) != self.n or any(b < 0 for b in batches):
            raise ValueError("Batch sizes must be nonnegative and sum to n")
        positive_difference = Fraction(0)
        q_total_count = defaultdict(Fraction)
        joint_count_cells = 0

        def descend(j, completed, mismatches, q_prefix, p_prefix):
            nonlocal positive_difference, joint_count_cells
            if j == len(batches):
                joint_count_cells += 1
                positive_difference += max(Fraction(0), q_prefix - p_prefix)
                q_total_count[mismatches] += q_prefix
                return
            size = batches[j]
            q_batch = self.binomial(size, self.predictive(completed, mismatches))
            p_batch = self.teacher_binomial(size)
            for new_m, (q, p) in enumerate(zip(q_batch, p_batch)):
                descend(j + 1, completed + size, mismatches + new_m,
                        q_prefix * q, p_prefix * p)

        descend(0, 0, 0, Fraction(1), Fraction(1))
        if sum(q_total_count.values()) != 1:
            raise AssertionError("The exact schedule output does not sum to one")
        teacher_total_count = self.teacher_binomial(self.n)
        symmetrized_tv = sum(abs(q_total_count[m] - teacher_total_count[m])
                            for m in range(self.n + 1)) / 2
        if symmetrized_tv > positive_difference:
            raise AssertionError("Total-count data processing inequality failed")
        if len([b for b in batches if b]) == 1:
            one_batch_tv = sum(abs(p - q) for p, q in zip(
                teacher_total_count, self.binomial(self.n, self.predictive(0, 0)))) / 2
            if symmetrized_tv != positive_difference or positive_difference != one_batch_tv:
                raise AssertionError("One nonempty batch must equal its direct binomial TV")
        return positive_difference, symmetrized_tv, joint_count_cells

    def row(self, batches):
        tv, sym_tv, cells = self.evaluate(tuple(batches))
        return {"batch_sizes": list(batches), "tv_exact": shown(tv),
                "symmetrized_tv_exact": shown(sym_tv), "joint_count_cells": cells}


def literal_laws(oracle):
    """Full labeled 2n-coordinate P and R; no count transition kernels."""
    teacher, model = {}, {}
    for x in product((0, 1), repeat=2 * oracle.n):
        m = sum(x[i] != x[oracle.n + i] for i in range(oracle.n))
        teacher[x] = Fraction(1, 2**oracle.n) * oracle.tau**m * (1 - oracle.tau)**(oracle.n - m)
        model[x] = Fraction(1, 2**oracle.n) * sum(
            w * p**m * (1 - p)**(oracle.n - m)
            for w, p in zip(oracle.weights, oracle.probabilities))
    if sum(teacher.values()) != 1 or sum(model.values()) != 1:
        raise AssertionError("Literal input laws do not normalize")
    return teacher, model


def literal_policy_law(oracle, batches, pair_order, model):
    """Products of literal heads frozen before each coordinate batch."""
    coordinate_batches = [tuple(range(oracle.n))]
    offset = 0
    for size in batches:
        coordinate_batches.append(tuple(oracle.n + pair_order[j]
                                        for j in range(offset, offset + size)))
        offset += size

    @lru_cache(None)
    def head(revealed, values, coordinate, bit):
        denominator = sum(p for x, p in model.items()
                          if all(x[i] == v for i, v in zip(revealed, values)))
        numerator = sum(p for x, p in model.items()
                        if x[coordinate] == bit
                        and all(x[i] == v for i, v in zip(revealed, values)))
        return numerator / denominator

    law = {}
    for x in model:
        probability = Fraction(1)
        revealed = ()
        for batch in coordinate_batches:
            values = tuple(x[i] for i in revealed)
            for coordinate in batch:
                probability *= head(revealed, values, coordinate, x[coordinate])
            revealed += batch
        law[x] = probability
    if sum(law.values()) != 1:
        raise AssertionError("Literal policy law does not normalize")
    return law


def self_tests():
    started = time.perf_counter()
    checks = []
    literal_cases = 0
    for n, batches in ((2, (1, 1)), (2, (0, 2, 0)), (3, (1, 2)),
                       (3, (2, 1)), (3, (1, 0, 2)), (3, (1, 1, 1))):
        oracle = ExactFairOracle({"n": n, "tau": "1/4",
                                  "weights": ["2/3", "1/3"],
                                  "probabilities": ["1/4", "1/2"]})
        teacher, model = literal_laws(oracle)
        fixed = literal_policy_law(oracle, batches, tuple(range(n)), model)
        fixed_tv = sum(abs(teacher[x] - fixed[x]) for x in teacher) / 2
        sym_law = dict.fromkeys(teacher, Fraction(0))
        for ordering in permutations(range(n)):
            law = literal_policy_law(oracle, batches, ordering, model)
            for x in sym_law:
                sym_law[x] += law[x] / math.factorial(n)
        sym_tv = sum(abs(teacher[x] - sym_law[x]) for x in teacher) / 2
        calculated_tv, calculated_sym, _ = oracle.evaluate(batches)
        if fixed_tv != calculated_tv or sym_tv != calculated_sym:
            raise AssertionError("Independent full 2n-coordinate cross-check failed")
        literal_cases += 1
    checks.append(f"{literal_cases} literal full-output fixed/random-permutation TV identities, n=2,3")
    target_cases = 0
    for n in (2, 3, 8, 16):
        oracle = ExactFairOracle({"n": n, "tau": "1/4", "weights": ["1"],
                                  "probabilities": ["1/4"]})
        for r in (1, 2, 3):
            for batches in {geometric_batches(n, r), equal_batches(n, r), (n,) + (0,) * (r - 1)}:
                tv, sym_tv, _ = oracle.evaluate(batches)
                if tv != 0 or sym_tv != 0:
                    raise AssertionError("R=P must be sampled exactly in at least two rounds")
                target_cases += 1
    checks.append(f"{target_cases} exact-target schedule zero-TV controls, n=2,3,8,16")
    for n in range(1, 33):
        for r in range(1, 5):
            for j in range(1, r + 1):
                root = floor_root_power(n, j, r)
                if not root**r <= n**j < (root + 1)**r:
                    raise AssertionError("Exact geometric schedule root failure")
    checks.append("exact integer geometric-root inequalities n=1,...,32, r=1,...,4")
    return {"passed": True, "checks": checks, "elapsed_seconds": time.perf_counter() - started}


def benchmark(witness, certificate, rounds):
    started = time.perf_counter()
    oracle = ExactFairOracle(witness)
    for key in ("n", "tau", "weights", "probabilities"):
        if witness[key] != certificate[key]:
            raise ValueError(f"Frozen witness/certificate mismatch in {key}")
    if not (certificate["model"]["kl_budget_certified"]
            and certificate["model"]["head_bound_certified"]):
        raise ValueError("An input model lacks certified KL/head constraints")
    if exact(certificate["model"]["kl_budget"]) != exact(witness["budget"]):
        raise ValueError("Witness and certificate KL budgets differ")
    if exact(certificate["model"]["head_bound"]) != exact(witness["head_bound"]):
        raise ValueError("Witness and certificate head bounds differ")
    case = next(c for c in certificate["cases"] if int(c["K"]) == rounds)
    lower, upper = exact(case["tv_lower_certified"]), exact(case["tv_upper_certified"])
    if not 0 <= lower <= upper <= 1:
        raise ValueError("Invalid all-policy certificate interval")
    r = rounds - 1
    geometric, equal = geometric_batches(oracle.n, r), equal_batches(oracle.n, r)
    all_rows = []
    for batches in compositions(oracle.n, r):
        row = oracle.row(batches)
        if exact(row["tv_exact"]) < lower or exact(row["symmetrized_tv_exact"]) < lower:
            raise AssertionError("A legal exact schedule violates the all-policy lower certificate")
        all_rows.append(row)
    if len(all_rows) != math.comb(oracle.n + r - 1, r - 1):
        raise AssertionError("Weak-composition enumeration is incomplete")
    minimum = min(exact(x["tv_exact"]) for x in all_rows)
    minimum_sym = min(exact(x["symmetrized_tv_exact"]) for x in all_rows)
    fixed_ties = [x for x in all_rows if exact(x["tv_exact"]) == minimum]
    sym_ties = [x for x in all_rows if exact(x["symmetrized_tv_exact"]) == minimum_sym]
    best_fixed, best_sym = fixed_ties[0], sym_ties[0]
    row = {
        "id": witness["id"], "n": oracle.n, "budget": witness["budget"], "K": rounds,
        "weights": witness["weights"], "probabilities": witness["probabilities"],
        "model_tv": certificate["model"]["model_tv_exact"],
        "actual_kl_lower": certificate["model"]["kl_lower"],
        "actual_kl_upper": certificate["model"]["kl_upper"],
        "all_policy": {"lower": shown(lower), "upper": shown(upper)},
        "geometric": oracle.row(geometric), "equal": oracle.row(equal),
        "best_fixed": best_fixed, "best_symmetrized": best_sym,
        "enumeration": {"schedule_count": len(all_rows),
                        "best_fixed_tie_batch_sizes": [x["batch_sizes"] for x in fixed_ties],
                        "best_symmetrized_tie_batch_sizes": [x["batch_sizes"] for x in sym_ties],
                        "all_schedules": all_rows},
        "geometric_excess_over_optimum_lower": shown(max(Fraction(0), exact(oracle.row(geometric)["tv_exact"]) - upper)),
        "geometric_excess_over_optimum_upper": shown(exact(oracle.row(geometric)["tv_exact"]) - lower),
        "best_fixed_excess_over_optimum_lower": shown(max(Fraction(0), minimum - upper)),
        "best_fixed_excess_over_optimum_upper": shown(minimum - lower),
        "head_cache_entries": oracle.predictive.cache_info().currsize,
        "elapsed_seconds": time.perf_counter() - started,
    }
    return row


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--witnesses", type=Path, required=True)
    parser.add_argument("--certificates", type=Path, required=True)
    parser.add_argument("--output", type=Path, required=True)
    parser.add_argument("--self-test", action="store_true")
    args = parser.parse_args()
    # Large exact denominators are research outputs, not untrusted integer text.
    if hasattr(sys, "set_int_max_str_digits"):
        sys.set_int_max_str_digits(0)
    started = time.perf_counter()
    witnesses = json.loads(args.witnesses.read_text())
    certificates = json.loads(args.certificates.read_text())
    if witnesses.get("status") != "complete":
        raise ValueError("Input witness selection must be complete")
    by_id = {w["id"]: w for w in certificates["witnesses"]}
    if len(by_id) != len(certificates["witnesses"]):
        raise ValueError("Duplicate certificate ids")
    witness_ids = [w["id"] for w in witnesses["witnesses"]]
    if len(set(witness_ids)) != len(witness_ids) or set(witness_ids) != set(by_id):
        raise ValueError("Witness and certificate id sets must match without duplicates")
    output = {
        "schema_version": 1, "status": "running",
        "metadata": {
            "witnesses_sha256": sha256(args.witnesses),
            "certificates_sha256": sha256(args.certificates),
            "source_sha256": sha256(__file__),
            "arithmetic": "exact fractions; floats are display only",
            "rounds": [3, 4],
            "policy": "Round 1 samples all fair A coordinates; fixed labeled B batches follow, with frozen pre-batch heads.",
            "fixed_tv": "Full-output TV equals TV of the JOINT vector of batch mismatch counts.",
            "symmetrized_tv": "Different policy: draw a uniform random permutation of pair labels before generation; marginalize that private randomness. Full-output TV then equals total mismatch count TV.",
            "optimization": "All ordered nonnegative compositions n into K-1 batches; oracle-specific optimum only within this schedule family, not an all-policy optimum or a uniformly chosen minimax schedule.",
            "tie_rule": "Record all exact ties; selected best is first in lexicographic batch-size order.",
            "geometric": "Cumulative sizes c_j=floor(n^(j/r)), c_0=0,c_r=n, computed by integer inequalities.",
            "equal": "Cumulative sizes c_j=floor(j*n/r), r=K-1.",
        },
        "self_test": self_tests() if args.self_test else {"passed": None, "checks": []},
        "rows": [],
    }
    args.output.parent.mkdir(parents=True, exist_ok=True)
    if args.output.exists():
        raise FileExistsError("Refusing to overwrite an existing result")
    with args.output.open("x") as stream:
        json.dump(output, stream, indent=2)
        stream.write("\n")
    for witness in witnesses["witnesses"]:
        for rounds in (3, 4):
            row = benchmark(witness, by_id[witness["id"]], rounds)
            output["rows"].append(row)
            args.output.write_text(json.dumps(output, indent=2) + "\n")
            print(f"SCHEDULE {row['id']} K={rounds}: geometric={row['geometric']['tv_exact']['float']:.10g}, "
                  f"equal={row['equal']['tv_exact']['float']:.10g}, best-fixed={row['best_fixed']['tv_exact']['float']:.10g}, "
                  f"best-sym={row['best_symmetrized']['symmetrized_tv_exact']['float']:.10g}, "
                  f"compositions={row['enumeration']['schedule_count']}, elapsed={row['elapsed_seconds']:.3f}s", flush=True)
    output["status"] = "complete"
    output["summary"] = {
        "witness_count": len(witnesses["witnesses"]), "row_count": len(output["rows"]),
        "schedule_evaluations": sum(r["enumeration"]["schedule_count"] for r in output["rows"]),
        "all_schedules_above_certified_lower": True,
        "all_data_processing_checks_passed": True,
        "elapsed_seconds": time.perf_counter() - started,
    }
    args.output.write_text(json.dumps(output, indent=2) + "\n")


if __name__ == "__main__":
    main()