climperor/draft_archetypes.py

"""Rule-based draft lineup archetypes and gap analysis (no AI).

Detects push / global enemy shapes, enemy & ally tag gaps, answer heroes,
and short Chinese analysis / reason strings for recommend marks.
"""

from __future__ import annotations

from collections import Counter
from typing import Iterable

from hero_tags import TAG_ORDER

# Strong push cores: one hit can flag push even before 2+ Pusher tags.
PUSH_CORE = frozenset({
    "lycan",
    "furion",
    "broodmother",
    "chen",
    "enchantress",
    "visage",
    "beastmaster",
    "naga_siren",
    "lone_druid",
    "undying",
})

GLOBAL_SET = frozenset({
    "furion",
    "spectre",
    "wisp",
    "abyssal_underlord",
    "zuus",
    "ancient_apparition",
    "spirit_breaker",
    "storm_spirit",
    "rattletrap",
})

HARD_GLOBAL = frozenset({
    "furion",
    "spectre",
    "wisp",
})

# Archetype -> answer hero keys (marked 克 with reason 对推进 / 对全球流).
ARCHETYPE_ANSWERS: dict[str, tuple[str, ...]] = {
    "push": (
        "medusa",
        "terrorblade",
        "naga_siren",
        "jakiro",
        "gyrocopter",
        "dragon_knight",
        "shredder",
    ),
    "global": (
        "storm_spirit",
        "anti_mage",
        "riki",
        "bounty_hunter",
        "queenofpain",
        "ember_spirit",
    ),
}

ARCHETYPE_REASON = {
    "push": "对推进",
    "global": "对全球流",
}

ARCHETYPE_LABEL = {
    "push": "偏推进",
    "global": "全球流",
}

# Gaps we report (user-facing). 输出 is proxied by 核心.
GAP_TAGS = ("控制", "爆发", "核心", "先手")

GAP_DISPLAY = {
    "控制": "控制",
    "爆发": "爆发",
    "核心": "输出",
    "先手": "先手",
}

# Enemy gap -> candidate tags that punish it (marked 克).
ENEMY_GAP_PUNISH: dict[str, tuple[str, ...]] = {
    "控制": ("控制", "先手"),
    "爆发": ("耐久", "核心"),
    "核心": ("爆发", "控制"),
    "先手": ("先手", "爆发"),
}

MAX_REASONS = 3
MAX_REASON_LEN = 12


def tag_profile(keys: Iterable[str], tags_by_key: dict[str, list[str]]) -> dict[str, int]:
    counts: Counter[str] = Counter()
    for key in keys:
        for tag in tags_by_key.get(key) or []:
            if tag in TAG_ORDER:
                counts[tag] += 1
    return {t: counts[t] for t in TAG_ORDER if counts.get(t)}


def detect_archetypes(
    enemies: list[str],
    tags_by_key: dict[str, list[str]],
    *,
    push_tag_min: int = 2,
) -> list[str]:
    """Return ordered archetype ids present in the enemy lineup."""
    out: list[str] = []
    push_n = sum(1 for e in enemies if "推进" in (tags_by_key.get(e) or []))
    if push_n >= push_tag_min or any(e in PUSH_CORE for e in enemies):
        out.append("push")
    global_hits = [e for e in enemies if e in GLOBAL_SET]
    if len(global_hits) >= 2 or any(e in HARD_GLOBAL for e in enemies):
        out.append("global")
    return out


def detect_gaps(
    profile: dict[str, int],
    *,
    hero_count: int,
    min_heroes: int = 2,
) -> list[str]:
    """Return missing GAP_TAGS when enough heroes are locked."""
    if hero_count < max(1, int(min_heroes)):
        return []
    missing = []
    for tag in GAP_TAGS:
        if int(profile.get(tag) or 0) <= 0:
            missing.append(tag)
    return missing


def format_analysis(
    *,
    archetypes: list[str],
    enemy_gaps: list[str],
    ally_gaps: list[str],
    ally_count: int,
) -> str:
    """One short Chinese lineup summary (may be empty)."""
    enemy_bits: list[str] = []
    for arch in archetypes:
        lab = ARCHETYPE_LABEL.get(arch)
        if lab and lab not in enemy_bits:
            enemy_bits.append(lab)
    for gap in enemy_gaps:
        disp = GAP_DISPLAY.get(gap, gap)
        bit = f"缺{disp}"
        if bit not in enemy_bits:
            enemy_bits.append(bit)

    ally_bits: list[str] = []
    if ally_count <= 0:
        if enemy_bits:
            ally_bits.append("缺口尚不明")
    else:
        for gap in ally_gaps:
            disp = GAP_DISPLAY.get(gap, gap)
            bit = f"缺{disp}"
            if bit not in ally_bits:
                ally_bits.append(bit)

    parts: list[str] = []
    if enemy_bits:
        parts.append("敌：" + "·".join(enemy_bits))
    if ally_bits:
        parts.append("我：" + "·".join(ally_bits))
    text = " | ".join(parts)
    if len(text) > 40:
        text = text[:39] + "…"
    return text


def _trim_reason(s: str) -> str:
    s = (s or "").strip()
    if len(s) <= MAX_REASON_LEN:
        return s
    return s[: MAX_REASON_LEN - 1] + "…"


def collect_reasons(
    *,
    names: dict[str, str],
    beats: list[dict],
    with_allies: list[dict],
    archetype_hits: list[str],
    punish_gaps: list[str],
    fill_gaps: list[str],
) -> list[str]:
    """Build up to MAX_REASONS short reason phrases for one candidate."""
    reasons: list[str] = []

    def add(phrase: str) -> None:
        p = _trim_reason(phrase)
        if p and p not in reasons and len(reasons) < MAX_REASONS:
            reasons.append(p)

    # Prefer one signal per mark type (克 / 补 / 搭) before extras.
    for edge in beats[:1]:
        add(f"克{names.get(edge['enemy'], edge['enemy'])}")
    for gap in fill_gaps[:1]:
        add(f"补{GAP_DISPLAY.get(gap, gap)}")
    for edge in with_allies[:1]:
        add(f"搭{names.get(edge['ally'], edge['ally'])}")
    for arch in archetype_hits:
        add(ARCHETYPE_REASON.get(arch, arch))
    for gap in punish_gaps:
        add(f"打缺{GAP_DISPLAY.get(gap, gap)}")
    for edge in beats[1:]:
        add(f"克{names.get(edge['enemy'], edge['enemy'])}")
    for gap in fill_gaps[1:]:
        add(f"补{GAP_DISPLAY.get(gap, gap)}")
    for edge in with_allies[1:]:
        add(f"搭{names.get(edge['ally'], edge['ally'])}")
    return reasons


def answer_for_candidate(
    key: str,
    cand_tags: list[str],
    *,
    archetypes: list[str],
    enemy_gaps: list[str],
    ally_gaps: list[str],
) -> tuple[list[str], list[str], list[str]]:
    """Return (archetype_hits, punish_gaps, fill_gaps) that apply to this hero."""
    tag_set = set(cand_tags or [])
    arch_hits = [a for a in archetypes if key in ARCHETYPE_ANSWERS.get(a, ())]
    punish = []
    for gap in enemy_gaps:
        wanted = ENEMY_GAP_PUNISH.get(gap) or ()
        if tag_set.intersection(wanted):
            punish.append(gap)
    fill = [g for g in ally_gaps if g in tag_set]
    # 核心 gap displays as 输出; candidate must have 核心 tag to fill.
    return arch_hits, punish, fill


__all__ = [
    "ARCHETYPE_ANSWERS",
    "ARCHETYPE_LABEL",
    "ARCHETYPE_REASON",
    "ENEMY_GAP_PUNISH",
    "GAP_DISPLAY",
    "GAP_TAGS",
    "answer_for_candidate",
    "collect_reasons",
    "detect_archetypes",
    "detect_gaps",
    "format_analysis",
    "tag_profile",
]