"""Exact bounded random replacement illustration, not a StatCache implementation."""
from collections import defaultdict
from fractions import Fraction
import json
from pathlib import Path
import sys


def fraction(value):
    return {"numerator": value.numerator, "denominator": value.denominator}


def evaluate(trace, capacity):
    if not isinstance(trace, str) or not 1 <= len(trace) <= 12:
        raise ValueError("Use a nonempty trace of at most 12 uppercase letters")
    if any(not "A" <= key <= "Z" for key in trace):
        raise ValueError("Trace entries must be uppercase ASCII letters")
    if type(capacity) is not int or not 1 <= capacity <= 4:
        raise ValueError("Capacity must be an integer from 1 to 4")
    states = {frozenset(): Fraction(1)}
    seen, events = set(), []
    total, noncold = Fraction(0), Fraction(0)
    lru, lru_misses = [], 0
    for index, key in enumerate(trace):
        following = defaultdict(Fraction)
        miss = evictions = Fraction(0)
        cold = key not in seen
        for resident, mass in states.items():
            if key in resident:
                following[resident] += mass
            else:
                miss += mass
                if len(resident) < capacity:
                    following[resident | {key}] += mass
                else:
                    evictions += mass
                    for victim in sorted(resident):
                        following[(resident - {victim}) | {key}] += mass / capacity
        if sum(following.values()) != 1:
            raise ArithmeticError("Probability mass was not conserved")
        total += miss
        if not cold:
            noncold += miss
        if key in lru:
            lru.remove(key)
        else:
            lru_misses += 1
            if len(lru) == capacity:
                lru.pop(0)
        lru.append(key)
        seen.add(key)
        events.append({
            "index": index, "key": key, "cold": cold,
            "missProbability": fraction(miss),
            "evictionProbability": fraction(evictions),
            "statesAfter": [
                {"resident": "".join(sorted(s)), "probability": fraction(p)}
                for s, p in sorted(following.items(), key=lambda item: "".join(sorted(item[0])))
            ],
        })
        states = following
    requests, reuses = len(trace), len(trace) - len(seen)
    return {
        "trace": trace, "capacitySlots": capacity, "requests": requests,
        "coldRequests": len(seen), "reuseRequests": reuses,
        "expectedMisses": fraction(total), "expectedNoncoldMisses": fraction(noncold),
        "allMissesPerRequest": fraction(total / requests),
        "noncoldMissesPerRequest": fraction(noncold / requests),
        "missesPerReuse": fraction(noncold / reuses) if reuses else None,
        "lruMisses": lru_misses, "events": events,
    }


def evidence():
    return {
        "schemaVersion": 1,
        "kind": "constructed exact arithmetic",
        "method": "Enumerate and merge all resident-set states using exact rational probabilities.",
        "assumptions": [
            "Initially empty, fully associative, equal-size demand-admitted cache.",
            "Every full-cache miss evicts one uniformly and independently chosen resident entry.",
            "Hits do not evict; filling a free slot does not evict.",
            "No prefetch, bypass, TTL, writes, concurrency, byte-size effects or measured timings.",
        ],
        "scope": "Not a StatCache estimator or author benchmark reproduction.",
        "rows": [evaluate(trace, 2) for trace in ("ABBA", "ABCA", "ABCDA")],
    }


def main():
    args = sys.argv[1:]
    if args not in ([], ["--check"]):
        raise SystemExit("Use no arguments to generate, or --check to verify")
    path = Path(__file__).with_name("evidence.json")
    content = json.dumps(evidence(), indent=2) + "\n"
    if args == ["--check"]:
        if path.read_text() != content:
            raise SystemExit("Generated StatCache illustration differs from source")
    else:
        path.write_text(content)


if __name__ == "__main__":
    main()
