"""Last-pass repairs on a model reply, before the employee reads it.

A system prompt is a request, not a guarantee. Production, 2026-08-17: the
prompt said "when you name Helix, give the link", and the model answered
「在 PingCAP，你可以通过 **IT 系统** 申请邮箱别名」 — it dodged the rule by never
naming Helix, and the employee was left with a noun instead of somewhere to
tap. The same class of miss will recur with any instruction phrased as a
condition the model can route around.

So the prompt states the rule (it produces better replies when followed) and
this module makes the outcome deterministic when it is not. Nothing here
rewrites meaning: it only appends the destination the sentence already implied.
"""
from __future__ import annotations

import re

from app.core.locale import DEFAULT_LANG, Lang

#: Markdown the model writes and a Feishu *text* message does not render, so
#: 「你目前在 **12 个** 邮件组里」 reaches the employee with the asterisks in it.
#: Stripped rather than converted: a text message has no bold, and leaving the
#: markers in is the visible defect.
#: Single-line, and neither end may touch a digit. ``re.S`` with a bare
#: ``(.+?)`` — the first shape — let two unrelated literal ``**`` swallow
#: everything between them: 「计算 2**3 的结果是 8，另外 5**2 是 25」 came out as
#: 「计算 23 …，另外 52 是 25」, and 「手机 138**5678」 lost its mask. Exponent
#: and masking notation is always digit-adjacent; emphasis, in every language
#: the assistant speaks, is not. Kept digit-based rather than word-based on
#: purpose — Chinese writes 「你的**保修期**是」 with no spaces, and a
#: ``(?<!\w)`` guard would leave those asterisks on screen.
#: Newlines ARE allowed inside: a model wraps a long bold phrase across lines
#: often enough to matter, and the digit guards already cover the false
#: positives that banning them was protecting against.
_BOLD = re.compile(r"(?<![\d*])\*\*(?!\s)([^*]{1,300}?)(?<!\s)\*\*(?![\d*])")
#: ``***text***`` is bold+italic and standard model output. Stripped BEFORE
#: ``_BOLD``, which cannot match it: its content class excludes ``*``, so the
#: inner marker of a triple star has nothing to match and the whole run reached
#: the employee with all six asterisks intact.
_BOLD_ITALIC = re.compile(
    r"(?<![\d*])\*\*\*(?!\s)([^*]{1,300}?)(?<!\s)\*\*\*(?![\d*])",
)
#: Emphasis opens at a human word boundary: start of line, after whitespace,
#: or after a non-ASCII character (Chinese and Japanese write 「你的*重点*是」
#: with no spaces). A plain digit guard — the round-3 correction — was too
#: loose in the other direction and swallowed anything with two tight
#: asterisks on one line, which on an IT help desk means globs and paths:
#: 「日志在 /var/log/*.log 和 /tmp/*.tmp 里」 came out as 「/var/log/.log 和
#: /tmp/.tmp」, and 「user*@pingcap.com 或 admin*@pingcap.com」 lost both stars.
#: A word guard was too tight (it left 「*斜体*测试」 on screen); the boundary
#: test is what actually separates the two.
_ITALIC = re.compile(
    r"(?:^|(?<=[\s])|(?<=[^\x00-\x7F]))"
    # Content may not OPEN with a path or glob character. The closing
    # lookahead admits any non-ASCII, and Chinese enumerates with 、 — so
    # 「请删除 *.log、*.bak 和 *.tmp 文件」 read `.log、` as emphasis and came
    # back as 「请删除 .log、.bak 和 *.tmp」, losing two wildcards and keeping
    # the third. On an IT reply distinguishing an allowed domain wildcard from
    # a blocked one, that changes the meaning.
    r"\*(?![\s./\\])([^*\n]+?)(?<!\s)\*"
    r"(?=$|[\s]|[^\x00-\x7F]|[,.;:!?)\]])",
    re.M,
)
_CODE = re.compile(r"`([^`\n]+)`")
#: A heading marker needs the space after it. ``\s*`` — the first shape —
#: also ate the ``#`` from 「#1 号问题已解决」 and from ticket references like
#: ``#2946`` at the start of a line.
#: A heading marker is followed by a space — or, in Chinese and Japanese, by
#: nothing at all: 「##保修信息」 and 「###まとめ」 are how models actually write
#: them, and requiring the space left those markers on screen. Requiring
#: NOTHING ate the ``#`` from 「#1 号问题已解决」 and from ``#2946``. So: a
#: space, or a non-ASCII character — which no ticket reference starts with.
_HEADING = re.compile(r"^\s{0,3}#{1,6}(?:[ \t]+|(?=[^\x00-\x7F]))", re.M)
_BULLET = re.compile(r"^(\s*)[-*+]\s+", re.M)
#: ``[看这里](https://…)`` — keep the destination, which is the useful half.
_LINK = re.compile(r"\[([^\]]+)\]\((https?://[^)\s]+)\)")
_BLANK_RUN = re.compile(r"\n{3,}")

# Grounded people can be represented by this marker in an assistant reply.
# The Feishu delivery layer resolves it to a native ``<at>`` tag; other MCP
# clients can safely treat it as visible text.
FEISHU_MENTION = re.compile(
    r"\[\[helix_mention:(?P<person_id>[0-9a-fA-F-]{36}):(?P<label>[^\]]{1,160})\]\]",
)

PORTAL = "https://helix.pingcap.net"
PORTAL_REQUESTS = f"{PORTAL}/my/requests"

#: Ways a reply points at "somewhere else" without saying where. Matching is on
#: the vague phrase, not on the absence of a link, so a reply that already
#: carries one is left alone below.
#: ``(?!管理员|…)`` because 「IT 系统管理员」 is a *person*, and telling an
#: employee who was pointed at a human to "submit it yourself in Helix" is a
#: non-sequitur. The vague-destination rule is about places, not people.
#: One rule per language, and each one excludes PEOPLE. The first cut only
#: taught the Chinese branch about 管理员, so 「请联系 IT 部门的同事」 still got
#: 「在 Helix 自助提交」 bolted on (a non-sequitur — the reply named a person),
#: while English "the IT department" and Japanese 「IT 部門」 matched nothing at
#: all and never got the link they were supposed to get.
#: Japanese names a person as 担当者, and 「IT 部門の担当者」 puts の in between —
#: the same reason the Chinese list carries 的同事 as well as 同事. Without it the
#: ja branch had the guard in form only: 「IT 部門の担当者にご相談ください」 got
#: 「在 Helix 自助提交」 appended, in the wrong language, to a sentence that had
#: just named a human. Found by parametrising the guard test over all four
#: alternatives instead of testing the Chinese one and assuming the rest.
_PEOPLE = (
    r"(?!\s*(?:管理员|管理者|的同事|同事|の担当者|担当者|担当|窓口"
    r"|admin|administrator|team|staff))"
)
_VAGUE_PLATFORM = re.compile(
    rf"IT\s*系统{_PEOPLE}"
    rf"|IT\s*部门{_PEOPLE}"
    # ``那边`` needs the people guard too, and was the one branch of four that
    # shipped without it — the same omission the paragraph above records for the
    # first cut, one alternative over. 「找 IT 那边的同事」 named a PERSON and
    # still got 「在 Helix 自助提交」 bolted on.
    rf"|IT\s*那边{_PEOPLE}"
    rf"|the\s+IT\s+(?:system|department|portal){_PEOPLE}"
    rf"|IT\s*(?:システム|部門){_PEOPLE}",
    re.IGNORECASE,
)

_WHERE: dict[Lang, str] = {
    "zh": f"（在 Helix 自助提交：{PORTAL_REQUESTS}）",
    "en": f"(Submit it yourself in Helix: {PORTAL_REQUESTS})",
    "ja": f"（Helix から自分で申請：{PORTAL_REQUESTS}）",
}


def _pick(table: dict[Lang, str], lang: Lang) -> str:
    return table.get(lang) or table[DEFAULT_LANG]


def to_feishu_text(reply: str) -> str:
    """Render a model's Markdown as the plain text Feishu will actually show.

    Feishu ``text`` messages have no styling, so every marker the model writes
    is literal on screen. Order matters: links before bold, so a bold link does
    not lose its URL.
    """
    text = reply or ""
    text = _LINK.sub(lambda m: f"{m.group(1)}：{m.group(2)}", text)
    text = _BOLD_ITALIC.sub(r"\1", text)
    text = _BOLD.sub(r"\1", text)
    text = _ITALIC.sub(r"\1", text)
    text = _CODE.sub(r"\1", text)
    text = _HEADING.sub("", text)
    text = _BULLET.sub(r"\1· ", text)
    return _BLANK_RUN.sub("\n\n", text).strip()


def add_missing_destination(reply: str, lang: Lang) -> str:
    """Append the Helix link when a reply sends the employee nowhere.

    Only fires when the reply gestures at a system *and* carries no link of its
    own — a reply that already links, or never points anywhere, is untouched.
    """
    text = (reply or "").strip()
    if not text:
        return reply
    if "http://" in text or "https://" in text:
        return text
    if not _VAGUE_PLATFORM.search(text):
        return text
    return f"{text}\n{_pick(_WHERE, lang)}"


def to_web_markdown(reply: str) -> str:
    """Render a model reply for a browser, which *can* show Markdown.

    The web panel renders Markdown, so — unlike :func:`to_feishu_text` — nothing
    is flattened here. The one thing that must still change is the mention
    marker: ``[[helix_mention:<uuid>:<label>]]`` is an instruction to the Feishu
    delivery layer, and a browser has no such layer. Left alone it reaches the
    employee as a raw token with a person's internal id in it — an answer that
    looks broken AND discloses a UUID for no reason.

    Replaced with ``@Label``, which is what the marker means everywhere it is
    not a native Feishu tag. Deliberately not a link: a mention names who is
    responsible, and a profile URL invites a click that answers nothing they
    asked.
    """
    text = reply or ""
    return FEISHU_MENTION.sub(lambda m: f"@{m.group('label')}", text)