Quiz Whiz

def options(raw: dict | None) -> dict:
    """A table's settings, from whatever the host asked for."""
    lib, six = clean_six((raw or {}).get("six") if isinstance(raw, dict) else None)
    return {"six": f"{lib}:{','.join(six)}", "quick": moves.choice(raw, "quick", (False, True), DEFAULTS["quick"])}

def clean_six(raw) -> tuple[str, list[str]]:
    """A library and its six categories from "library:a,b,c,d,e,f": a
    themed library plays its own six; General knowledge, any six of its
    categories (the host's, made good: unknown or doubled ones are
    replaced from the standard six)."""
    libs = library.libraries()
    lib, _, picked = str(raw or "").partition(":")
    if lib not in libs:
        lib = "general" if "general" in libs else libs[0]
    cats = library.catalog()[lib]
    if lib != "general":
        return lib, library.default_six(lib)
    six = []
    for s in picked.split(","):
        if s in cats and s not in six:
            six.append(s)
    for s in library.default_six(lib) + list(cats):
        if len(six) >= SIX:
            break
        if s not in six:
            six.append(s)
    return lib, six[:SIX]

def category(space: int) -> int | None:
    """The slot a space asks from, or None (roll again, the hub)."""
    if space == HUB:
        return None
    if space < RING:
        k, j = divmod(space, SIDE + 1)
        if j == 0:
            return k
        if j == ROLL_AGAIN_AT:
            return None
        return (k + 1 + j) % CORNERS
    k, s = divmod(space - RING, SPOKE)
    return (k + s + 1) % CORNERS

def destinations(start: int, steps: int) -> dict[int, list[int]]:
    """Every space a roll of `steps` can end on from `start`, each with one
    way there (the spaces passed through, ending on it): exactly `steps`
    moves, never straight back the way you just came (the box's rule), any
    branch at a junction, across the hub too."""
    nb = neighbors()
    found: dict[int, list[int]] = {}

    def walk(at, prev, left, path):
        if left == 0:
            found.setdefault(at, path)
            return
        for nxt in nb[at]:
            if nxt != prev:
                walk(nxt, at, left - 1, path + [nxt])
    walk(start, None, steps, [])
    return dict(sorted(found.items()))

def move(state, seat, action, now):
    if state["phase"] != "move":
        raise Illegal("Roll first.")
    if seat != state["up"]:
        raise Illegal("It's not your turn.")
    to = action.get("to")
    path = next((p for space, p in state["dests"] if space == to), None)
    if type(to) is not int or path is None:
        raise Illegal(f"Move {state['die']} spaces: pick one of the lit spaces.")
    state["pos"][seat] = to
    state["dests"] = []
    kind = board.kind(to)
    log.event(state, "move", seat=seat, at=to, path=path, space=kind, slot=board.category(to))
    if kind == "again":
        state["phase"] = "roll"
        log.event(state, "again", seat=seat)
        return
    if kind == "hub":
        if all_lit(state, seat):
            _final_pick(state)
        else:
            state["phase"] = "pick"
            state["pick_for"] = "hub"
            state["picker"] = seat
        return
    slot = board.category(to)
    _ask(state, slot, light=kind == "light" and not state["lit"][seat][slot])

def _draw(state: dict, slug_: str) -> dict:
    """A question from the category nobody at this table has had yet (since
    the category last ran out)."""
    cat = library.category(state["lib"], slug_)
    used = state["used"].setdefault(slug_, [])
    pool = [q for q in cat.questions if q["id"] not in set(used)]
    if not pool:
        used.clear()
        pool = list(cat.questions)
    q = random.Random(f"{state['seed']}:q:{slug_}:{state['asked']}").choice(pool)
    used.append(q["id"])
    return q

def answer(state, seat, action, now):
    if state["phase"] != "answer":
        raise Illegal("There's no question to answer.")
    if seat != state["up"]:
        raise Illegal("It's not your question.")
    q = state["q"]
    if "recall" in action:
        # (A bot's answer: whether it knows, its seat's to say; the words, the card's.)
        if seat not in state["bots"]:
            raise Illegal("Type your answer.")
        rng = random.Random(f"{state['seed']}:bot:{state['asked']}")
        text = _slip(q["answer"], rng) if action["recall"] and action.get("typo") else \
            q["answer"] if action["recall"] else _decoy(state, rng)
    else:
        text = action.get("text")
        if text is not None and not isinstance(text, str):
            raise Illegal("Type your answer.")
    text = clean(text, ANSWER_LEN)
    found = check_answer(text, q["accept"]) if text else {"verdict": "wrong", "form": q["answer"], "near": False}
    state["said"] = text
    state["verdict"] = found["verdict"]
    state["form"] = found["form"]
    log.event(state, "answer", seat=seat, text=text, verdict=found["verdict"], answer=q["answer"], slot=q["slot"])
    if found["verdict"] == "right":
        _right(state, now)
        return
    if found["verdict"] == "close":
        voters = [s for s in people(state) if s != seat]
        if not voters:
            # (No one to ask: the app judges a near miss alone.)
            log.event(state, "judged", count=found["near"], by="app", yes=0, no=0)
            if found["near"]:
                _right(state, now)
            else:
                _wrong(state, now, challenge=False)
            return
        state["phase"] = "judge"
        state["judging"] = {"why": "close", "voters": voters, "votes": {}, "until": now + JUDGE_SECS, "by": None,
                            "near": found["near"]}
        log.event(state, "close", seat=seat, text=text, answer=q["answer"])
        return
    _wrong(state, now, challenge=True)

def _resolve(state: dict, now: float) -> None:
    j = state["judging"]
    yes = sum(1 for v in j["votes"].values() if v)
    no = len(j["votes"]) - yes
    if j["why"] == "close":
        # (A near miss: ties count, and with no votes it's the app's call.)
        count = j["near"] if not j["votes"] else yes >= no
    else:
        count = yes > no  # (a challenge must win the table over)
    state["judging"] = {**j, "until": None, "result": count}
    log.event(state, "judged", count=count, by="table", yes=yes, no=no, why=j["why"])
    if count:
        _right(state, now)
    else:
        _wrong(state, now, challenge=False)

def plain(text: str) -> str:
    """The one plain form both sides are compared in."""
    s = unicodedata.normalize("NFKD", str(text or ""))
    s = "".join(c for c in s if not unicodedata.combining(c)).casefold()
    s = s.replace("&", " and ").replace("’", "'").replace("‘", "'")
    s = re.sub(r"(?<=\d),(?=\d{3}\b)", "", s)  # 1,000 → 1000
    s = re.sub(r"'", "", s)  # don't → dont, o'keeffe → okeeffe
    s = re.sub(r"[^\w\s]|_", " ", s)  # hyphens, periods, the rest: spaces
    words = s.split()
    while words and words[0] in ARTICLES and len(words) > 1:
        words = words[1:]
    return " ".join(_numbers(words))

def judge(text: str, accept) -> dict:
    """{"verdict": "right" | "close" | "wrong", "form": the accepted form it
    matched or came nearest, "near": whether a close answer is near enough
    for the app to count it alone}."""
    said = plain(text)
    forms = [f for f in dict.fromkeys(str(a) for a in accept or ()) if plain(f)]
    if not said or not forms:
        return {"verdict": "wrong", "form": forms[0] if forms else "", "near": False}
    squeezed = said.replace(" ", "")
    for f in forms:
        p = plain(f)
        if said == p or squeezed == p.replace(" ", ""):
            return {"verdict": "right", "form": f, "near": True}
    best = None
    for f in forms:
        p = plain(f)
        if _digits(p) != _digits(said):
            continue  # a different number is never a near miss
        target = p.replace(" ", "")
        d = distance(squeezed, target)
        if d <= slack(len(target)):
            near = d <= near_slack(len(target))
            if best is None or d < best[0]:
                best = (d, f, near)
        # The right answer with a word or two round it.
        sw, pw = said.split(), p.split()
        if len(pw) <= len(sw) <= len(pw) + EXTRA_WORDS and len(target) > 3:
            for i in range(len(sw) - len(pw) + 1):
                if sw[i:i + len(pw)] == pw and not ({"not", "no", "never"} & set(sw)):
                    if best is None or best[0] > 0:
                        best = (0.5, f, False)
    if best:
        return {"verdict": "close", "form": best[1], "near": best[2]}
    return {"verdict": "wrong", "form": forms[0], "near": False}

def slack(n: int) -> int:
    """How many slips a near miss of an answer this long may have."""
    if n <= 3:
        return 0
    if n <= 5:
        return 1
    if n <= 9:
        return 2
    return 3 if n <= 14 else 4

def near_slack(n: int) -> int:
    """How many slips the app forgives by itself."""
    return 0 if n <= 4 else 1 if n <= 10 else 2

def view(state: dict, seat) -> dict:
    phase = state["phase"]
    q = state["q"]
    shown = None
    if q:
        shown = {k: q[k] for k in ("slot", "level", "text", "light", "final", "seat")}
        if phase != "answer":
            # (Answered: the card is read out to everyone.)
            shown.update(answer=q["answer"], accept=q["accept"][:6], fact=q["fact"])
    j = state["judging"]
    me_voter = j is not None and seat is not None and seat in j["voters"]
    return {
        "game": slug, "seq": state["seq"], "n": state["n"], "phase": phase, "quick": state["quick"],
        "lib": state["lib"], "lib_title": dict(library.LIBRARIES).get(state["lib"], state["lib"]), "cats": _cats(state),
        "up": state["up"], "first": state["first"], "turn": state["turn"],
        "pos": list(state["pos"]) if state["pos"] else None, "lit": [list(r) for r in state["lit"]],
        "die": state["die"], "dests": [list(d) for d in state["dests"]],
        "kinds": {str(space): board.kind(space) for space, _ in state["dests"]},
        "q": shown, "said": state["said"], "verdict": state["verdict"], "counted": state["counted"],
        "form": state["form"] if phase != "answer" else None,
        "judging": {"why": j["why"], "voters": list(j["voters"]), "votes": dict(j["votes"]), "until": j.get("until"),
                    "by": j["by"], "result": j.get("result")} if j else None,
        "my_vote": j["votes"].get(str(seat)) if me_voter else None,
        "challengers": challengers(state), "review_until": state["review_until"],
        "picker": state["picker"], "pick_for": state["pick_for"],
        "score": [dict(s) for s in state["score"]],
        "bots": list(state["bots"]), "gone": sorted(state["gone"]),
        "finish": dict(state["finish"]) if state["finish"] else None, "rated": counts(state),
        "events": log.recent(state, seat),
    }

# How often a bot knows the answer, by its level and the question's.
KNOWS = {
    "easy": {"easy": 0.6, "medium": 0.35, "hard": 0.15},
    "medium": {"easy": 0.8, "medium": 0.6, "hard": 0.35},
    "hard": {"easy": 0.92, "medium": 0.8, "hard": 0.6},
}

def bot_action(state, seat, level, rng):
    v = view(state, seat)
    kind = next((k for s, k, _ in deciding(state) if s == seat), None)
    if kind in ("roll", "next"):
        return {"type": "roll"}
    if kind == "move":
        spaces = [space for space, _ in v["dests"]]
        if level == "easy" and rng.random() < 0.3:
            return {"type": "move", "to": rng.choice(spaces)}
        best = max(_score(v, seat, s, level) for s in spaces)
        return {"type": "move", "to": rng.choice([s for s in spaces if _score(v, seat, s, level) == best])}
    if kind == "pick":
        return {"type": "pick", "slot": rng.randrange(6)}
    if kind == "answer":
        q = v["q"]
        knows = rng.random() < KNOWS.get(level, KNOWS["medium"]).get(q["level"], 0.5)
        return {"type": "answer", "recall": knows, "typo": knows and rng.random() < TYPO}
    if kind == "vote":
        return {"type": "vote", "count": True}  # (never asked: bots don't vote)
    return {"type": "roll"}

@lru_cache(maxsize=1)
def catalog() -> dict[str, dict[str, Category]]:
    """Every library's playable categories, by slug, in the menu's order."""
    out: dict[str, dict[str, Category]] = {}
    for lib, _ in LIBRARIES:
        found: dict[str, Category] = {}
        for root in ROOTS:
            folder = root / lib
            if not folder.is_dir():
                continue
            for path in sorted(folder.glob("*.toml")):
                if path.stem not in found:
                    found[path.stem] = _read(path, lib, seed=root.name == "seed")
        order = ORDER.get(lib, ())
        ranked = sorted((c for c in found.values() if len(c) >= MIN_QUESTIONS),
                        key=lambda c: (order.index(c.slug) if c.slug in order else len(order), c.title))
        if len(ranked) >= 6:
            out[lib] = {c.slug: c for c in ranked}
    return out