"""The rules of the game: reading what the model wrote, and deciding how much of it to believe."""
import re
import unicodedata

MAX_INPUT = 300
ANNOUNCE = {"money", "gold", "health"}
AMOUNTS = {"money", "gold", "coins", "health"}

CHANGE = re.compile(r"^\s*(.+?)\s*<\|(add|set)\|>\s*(-?\s*\d+)\s*$")
SPELLED_MARKER = re.compile(r"<?\|\s*(vars|choices|sep|end|add|set)\s*\|\s*>?", re.I)
STRAY_MARKER = re.compile(r"<\|[a-z_]+\|>")


META_CHOICE = re.compile(
    r"leave (a )?comments?|rate (this|the) (story|game)|end (the )?game|give (me )?(a )?rating|"
    r"back to (the )?(menu|site|story list|main menu)|return to (the )?main menu|main menu|"
    r"play again|^\W*(restart|start over|start again|comments?)\W*$|(reset|refresh) (the )?game|"
    r"previous page|^\W*go back to the (beginning|start)\W*$|"
    r"^\W*(the )?end\W*(\[[^\]]*\]|\([^)]*\))?\W*$|^\W*the end of (the|this|your) "
    r"(tale|story|game|adventure|line)\W*$|this is the end of (your|the) (adventure|story|game)",
    re.I)


MONEY_WORDS = (
    r"\b(money|coins?|gold|silver|copper|cash|dollars?|bucks|credits?|price|pay|paid|"
    r"buy|bought|sell|sold|cost|steal|stole|stolen|rob|robbed|reward|bribe|purse|wallet|"
    r"payment|fee|tip|earn|earned|spend|spent|wage|loot|treasure)\b|\$"
)
HEALTH_WORDS = (
    r"\b(health|hurt|wound|wounded|injur\w*|bleed\w*|blood|pain|heal\w*|damage\w*|hit|"
    r"stab\w*|cut|bite|bitten|burn\w*|poison\w*|potion|bandage\w*|recover\w*|weak\w*)\b"
)
EVIDENCE = {
    "money": re.compile(MONEY_WORDS, re.I),
    "gold": re.compile(MONEY_WORDS, re.I),
    "health": re.compile(HEALTH_WORDS, re.I),
}


def is_story_choice(choice):
    return not META_CHOICE.search(choice)


def is_backed_by(name, narration):
    rule = EVIDENCE.get(name)
    return rule is None or bool(rule.search(narration))


def is_possible(name, old, new):
    if name not in AMOUNTS or old is None:
        return True
    return 0 <= new <= max(1000, 10 * old)


def clean_input(text):
    text = "".join(c for c in text if c == " " or unicodedata.category(c)[0] != "C")
    text = text.replace("<|", "<").replace("|>", ">")
    return re.sub(r"\s+", " ", text).strip()[:MAX_INPUT]


def state_text(state):
    return "<|sep|>".join(f"{name}\n{value}" for name, value in state.items())


def narration_so_far(raw):
    visible = re.split(r"<\||\|", raw, maxsplit=1)[0]
    return visible[:-1] if visible.endswith("<") else visible


def without_repeats(choices):
    seen, kept = set(), []
    for choice in choices:
        key = re.sub(r"\W+", " ", choice.lower()).strip()
        if key not in seen:
            seen.add(key)
            kept.append(choice)
    return kept


def parse_changes(text):
    changes, unreadable = [], []
    for item in filter(None, text.split("<|sep|>")):
        match = CHANGE.match(item)
        if match:
            name = re.sub(r"\s+", " ", match[1]).strip().lower()
            changes.append((name, match[2], int(match[3].replace(" ", ""))))
        else:
            unreadable.append(item)
    return changes, unreadable


def parse_turn(raw):
    problems = []
    fixed = SPELLED_MARKER.sub(lambda m: f"<|{m[1].lower()}|>", raw)
    if fixed != raw:
        problems.append("a marker written as text")
        raw = fixed

    narration, _, choice_text = raw.partition("<|choices|>")
    narration, _, change_text = narration.partition("<|vars|>")

    changes, unreadable = parse_changes(change_text)
    problems += [f"unreadable change {item!r}" for item in unreadable]

    choices = [c.strip() for c in choice_text.split("<|sep|>") if c.strip()]
    choices = without_repeats([c for c in choices if is_story_choice(c)])

    stray = STRAY_MARKER.findall(narration)
    if stray:
        problems.append(f"stray markers in the narration: {stray}")
        narration = STRAY_MARKER.sub(" ", narration)
    return narration.strip(), changes, choices, problems


def apply_changes(state, changes, narration):
    for name, op, value in changes:
        old = state.get(name)
        new = value if op == "set" else (old or 0) + value
        if not is_backed_by(name, narration):
            continue
        if name in ANNOUNCE and op == "set" and value != 0:
            continue
        if is_possible(name, old, new):
            state[name] = new