"""Conditional early-refresh arithmetic, not a cache or workload simulator."""
from decimal import Decimal, localcontext
from math import comb, isfinite
from pathlib import Path
import json
import sys


def number(value, positive=False):
    if isinstance(value, bool) or not isinstance(value, (int, float, Decimal)):
        raise ValueError("Expected a finite number")
    result = Decimal(str(value))
    if not result.is_finite() or result < 0 or (positive and result == 0):
        raise ValueError("Expected a positive number" if positive else "Expected a nonnegative number")
    if result != 0 and (not isfinite(float(result)) or float(result) == 0):
        raise ValueError("Nonzero inputs must be representable as finite nonzero floats")
    return result


def cohort(requests, remaining, duration, beta=1):
    """All requests see fixed metadata before any refresh can finish."""
    if type(requests) is not int or not 0 <= requests <= 1000:
        raise ValueError("requests must be an integer from 0 through 1000")
    r, delta, b = number(remaining), number(duration, True), number(beta, True)
    with localcontext() as context:
        context.prec = 70
        p = (-r / (delta * b)).exp()
        q = 1 - p
        if p == 1:
            probabilities = [Decimal(int(k == requests)) for k in range(requests + 1)]
        elif p == 0:
            probabilities = [Decimal(int(k == 0)) for k in range(requests + 1)]
        else:
            probabilities = [Decimal(comb(requests, k)) * p**k * q**(requests-k)
                             for k in range(requests + 1)]
        return {
            "request_count": requests,
            "remaining_seconds": float(r),
            "previous_recompute_seconds": float(delta),
            "beta": float(b),
            "per_request_refresh_probability": float(p),
            "expected_refresh_starts": float(requests * p),
            "probability_no_refresh": float(probabilities[0]),
            "probability_exactly_one": float(probabilities[1]) if requests else 0.0,
            "probability_multiple_refreshes": float(sum(probabilities[2:], Decimal(0))),
        }


def results():
    return {
        "schema_version": 1,
        "kind": "constructed_conditional_probability",
        "units": {"remaining": "seconds", "previous_recomputation": "seconds"},
        "assumptions": [
            "20 simultaneous requests for the same present cached value.",
            "Independent ideal uniform random choices and identical expiry metadata.",
            "No refreshed value is published before all decisions are made.",
            "Previous recomputation duration is 1 second and beta is 1.",
            "No lock, lease, coalescing, failure, load feedback or repeated expiry cycle."
        ],
        "rows": [cohort(20, remaining, 1) for remaining in (1, 3, 5)],
        "formula": "p=exp(-r/(beta*delta)); K~Binomial(m,p)",
        "scope": "Conditional example, not the paper's expected stampede over a request process."
    }


def serialized():
    return json.dumps(results(), indent=2, allow_nan=False) + "\n"


if __name__ == "__main__":
    args = sys.argv[1:]
    path = Path(__file__).with_name("results.json")
    if args == ["--write"]:
        path.write_text(serialized())
    elif args == ["--check"]:
        if path.read_text() != serialized():
            raise SystemExit("Stale probability results")
        print("Probability results match the generator")
    elif not args:
        print(serialized(), end="")
    else:
        raise SystemExit("Use --write, --check or no arguments")
