"""Independent exact C3 from the step-function definition, with no scorer imports.

For h_i on bins of width 1/(2n), f*f is piecewise linear, with
knot heights (sum_{i+j=k} h_i h_j)/(2n), plus zero endpoints.
Thus C3 = 2n max_k(sum_{i+j=k} h_i h_j)/(sum_i h_i)^2.

Finite decimal inputs are integers over a shared power of ten. We compute ALL
integer convolution coefficients via a carry-free integer polynomial square:
shift heights to nonnegative digits, square, unpack, undo the shift exactly.
The radix exceeds n*max(shifted_height)^2, so no coefficient carries.
"""
import argparse
from decimal import Decimal, localcontext
from fractions import Fraction
import hashlib
import json
from pathlib import Path
import time

def decimal_integer(value, places):
    sign, digits, exponent = value.as_tuple()
    coefficient = int("".join(map(str, digits)))
    return (-1 if sign else 1) * coefficient * 10 ** (exponent + places)

def convolution(a):
    n = len(a)
    shift = max(0, -min(a))
    upper = n * (max(a) + shift) ** 2
    width = max(1, (upper.bit_length() + 7) // 8)
    assert 1 << (8 * width) > upper
    packed = int.from_bytes(b"".join((x+shift).to_bytes(width, "little") for x in a), "little")
    squared = (packed * packed).to_bytes(width * (2*n-1), "little")
    prefix = [0]
    for x in a:
        prefix.append(prefix[-1] + x)
    coefficients = []
    for k in range(2*n-1):
        lo, hi = max(0, k-n+1), min(n-1, k)
        raw = int.from_bytes(squared[k*width:(k+1)*width], "little")
        coefficients.append(raw - 2*shift*(prefix[hi+1]-prefix[lo]) - (hi-lo+1)*shift**2)
    assert sum(coefficients) == sum(a)**2
    return coefficients, width

def decimals(value):
    with localcontext() as ctx:
        ctx.prec = 80
        return str(Decimal(value.numerator) / Decimal(value.denominator))

def audit(path):
    start = time.monotonic()
    tokens = [token for line in path.read_text().splitlines()
              for token in line.split("#", 1)[0].split()]
    values = [Decimal(t) for t in tokens]
    assert values and all(d.is_finite() for d in values)
    places = max(0, -min(d.as_tuple().exponent for d in values))
    a = [decimal_integer(d, places) for d in values]
    n = len(a)
    total = sum(a)
    assert total != 0, "Zero integral"
    c, width = convolution(a)
    maximum = max(0, max(c))
    minimum = min(0, min(c))
    argmax, argmin = c.index(maximum), c.index(minimum)
    spots = sorted(set([0, 1, n//3, n-1, argmax, argmin, 2*n-3, 2*n-2]))
    for k in spots:
        direct = sum(a[i]*a[k-i] for i in range(max(0, k-n+1), min(k, n-1)+1))
        assert direct == c[k], (k, direct, c[k])
    score = Fraction(2*n*maximum, total**2)
    absolute_score = Fraction(2*n*max(maximum, -minimum), total**2)
    integral = Fraction(total, 2*n*10**places)
    fraction = f"{score.numerator}/{score.denominator}"
    result = {
        "file": str(path), "file_sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
        "n": n, "decimal_scale": 10**places, "radix_bytes": width,
        "negative_heights": sum(x < 0 for x in a), "zero_heights": a.count(0),
        "min_height": str(min(values)), "max_height": str(max(values)),
        "integer_height_sum": total, "integral_fraction": str(integral),
        "integral_decimal": decimals(integral), "integral_squared": decimals(integral**2),
        "arena_integral_threshold_pass": integral**2 >= Fraction(1, 10**9),
        "arena_published_100000_limit_pass": n <= 100000,
        "max_integer_convolution": maximum, "min_integer_convolution": minimum,
        "argmax_zero_based": argmax, "argmin_zero_based": argmin,
        "max_multiplicity": c.count(maximum),
        "fraction": fraction, "fraction_sha256": hashlib.sha256(fraction.encode()).hexdigest(),
        "signed_max_score": decimals(score), "absolute_max_score": decimals(absolute_score),
        "margin_arena": decimals(Fraction("1.449121951852342")-score),
        "margin_arena_after_minImprovement": decimals(Fraction("1.449111951852342")-score),
        "margin_milo_printed": decimals(Fraction("1.4488860143")-score),
        "margin_milo_page": decimals(Fraction("1.4488860142647635")-score),
        "direct_sum_spot_checks": spots, "all_coefficients_sum_check": "pass",
        "elapsed_seconds": time.monotonic()-start,
    }
    return result

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("candidate", type=Path)
    parser.add_argument("--output", type=Path)
    args = parser.parse_args()
    result = audit(args.candidate)
    output = json.dumps(result, indent=2) + "\n"
    if args.output:
        args.output.write_text(output)
    print(output)