"""The term -> field-of-law assignment must be even, stable and honest."""

import field_assignment as fa

FIELDS = [f"Field {i:02d}" for i in range(26)]


def _dense(n_terms: int) -> dict[str, set[str]]:
    return {f"term_{i}": set(FIELDS) for i in range(n_terms)}


def test_derive_floor_is_integer_division() -> None:
    assert fa.derive_floor(160, 26) == 6
    assert fa.derive_floor(100, 26) == 3
    assert fa.derive_floor(26, 26) == 1
    assert fa.derive_floor(0, 26) == 0
    assert fa.derive_floor(160, 0) == 0


def test_dense_pool_is_evenly_spread() -> None:
    assignment = fa.assign_terms_to_fields(_dense(160))
    counts = assignment.assigned
    assert len(assignment.by_term) == 160
    assert min(counts.values()) == 6
    assert max(counts.values()) == 7
    assert sum(counts.values()) == 160


def test_every_term_assigned_exactly_once() -> None:
    assign = fa.assign_terms_to_fields(_dense(160))
    assert sorted(assign.by_term) == sorted(_dense(160))


def test_never_assigns_a_field_the_term_lacks() -> None:
    available = {
        "a": {"Field 00"},
        "b": {"Field 01", "Field 02"},
        "c": {"Field 02"},
    }
    assign = fa.assign_terms_to_fields(available)
    for term, field in assign.by_term.items():
        assert field in available[term]


def test_rebuild_is_identical() -> None:
    available = _dense(160)
    assert fa.assign_terms_to_fields(available) == fa.assign_terms_to_fields(available)


def test_adding_terms_moves_few_existing_assignments() -> None:
    """This is what protects verdicts already collected.

    Measured across 30 term vocabularies: 12-29 moved, mean 23. The bound of 45
    clears that spread while still failing a positional implementation, which
    moves all 160.
    """
    before = fa.assign_terms_to_fields(_dense(160)).by_term
    grown = _dense(160)
    for i in range(10):
        grown[f"extra_{i}"] = set(FIELDS)
    after = fa.assign_terms_to_fields(grown).by_term
    moved = sum(1 for term in before if before[term] != after[term])
    assert moved <= 45, f"{moved} of 160 moved"


def test_scarce_field_keeps_all_its_candidates() -> None:
    available = {f"term_{i}": set(FIELDS) for i in range(160)}
    scarce = "Field 07"
    for term in available:
        available[term].discard(scarce)
    for term in ("term_0", "term_1", "term_2"):
        available[term].add(scarce)
    assign = fa.assign_terms_to_fields(available)
    assert assign.assigned[scarce] == 3
    assert {assign.by_term[t] for t in ("term_0", "term_1", "term_2")} == {scarce}


def test_scarcity_ordering_does_not_starve_a_satisfiable_field() -> None:
    """Two thin fields share candidates. Naive field order lets the field
    visited first take terms the other one needed; scarcity order does not."""
    fields = ["Field A", "Field B"] + [f"Field {i:02d}" for i in range(4)]
    available: dict[str, set[str]] = {}
    for i in range(24):
        available[f"common_{i}"] = {f"Field {j:02d}" for j in range(4)}
    for i in range(4):
        available[f"shared_{i}"] = {"Field A", "Field B"}
    for i in range(4):
        available[f"onlyA_{i}"] = {"Field A"}
    assign = fa.assign_terms_to_fields(available, terms_per_field=4)
    assert assign.assigned["Field B"] == 4, "Field B was starved by a greedy Field A"


def test_achievable_floor_is_bounded_by_the_scarcest_field() -> None:
    available = {f"term_{i}": set(FIELDS) for i in range(160)}
    for term in available:
        available[term].discard("Field 07")
    available["term_0"].add("Field 07")
    assert fa.assign_terms_to_fields(available).achievable_floor() == 1


def test_achievable_floor_is_bounded_by_even_division() -> None:
    assert fa.assign_terms_to_fields(_dense(160)).achievable_floor() == 6


def test_explicit_floor_overrides_the_derivation() -> None:
    assign = fa.assign_terms_to_fields(_dense(160), terms_per_field=2)
    assert min(assign.assigned.values()) >= 2
    assert len(assign.by_term) == 160
    assert assign.floor == 2
    assert assign.floor_source == "explicit"


def test_empty_input_returns_empty_assignment() -> None:
    assign = fa.assign_terms_to_fields({})
    assert assign.by_term == {}
    assert assign.fields == ()
    assert assign.achievable_floor() == 0


def test_assignment_carries_the_floor_it_used() -> None:
    """Diagnostics read these off the decision; re-deriving them from the
    input pool and the finished template is what let the two drift apart."""
    assign = fa.assign_terms_to_fields(_dense(160))
    assert assign.floor == 6
    assert assign.floor_source == "derived"
    assert assign.n_terms == 160
    assert assign.fields == tuple(FIELDS)
    assert assign.candidates["Field 00"] == 160
    assert sum(assign.assigned.values()) == 160