"""Ритм и типографика: то, что скилл велит измерять дисперсией, а не на глаз.

Закрывает пункты чеклиста «вариативность длины предложений — не средняя, а
ДИСПЕРСИЯ» и «ноль длинных тире». Burstiness тут — статистический прокси, не сам
детектор: высокий разброс длины предложений коррелирует с человеческим письмом
(SKILL.md, раздел «Что ловят детекторы»).
"""

from __future__ import annotations

import re
import statistics
from dataclasses import dataclass

from razdel import sentenize, tokenize


@dataclass
class RhythmStats:
    sentences: int
    words: int
    mean_len: float          # средняя длина предложения в словах
    stdev_len: float         # стандартное отклонение длины
    cv_len: float            # коэффициент вариации = stdev/mean (главный показатель)
    min_len: int
    max_len: int
    short_share: float       # доля предложений < 5 слов
    long_share: float        # доля предложений > 25 слов
    em_dash: int             # длинных тире «—»
    ellipsis: int            # многоточий
    parentheses: int         # скобочных ремарок
    questions: int           # вопросительных предложений
    staccato_runs: int = 0   # цепочек из 3+ обрывков подряд (каталог #49)
    staccato_max: int = 0    # длина самой длинной такой цепочки

    def as_dict(self) -> dict:
        return self.__dict__.copy()


_WORD_RE = re.compile(r"[А-Яа-яЁёA-Za-z0-9]")


def _word_count(sentence: str) -> int:
    return sum(1 for t in tokenize(sentence) if _WORD_RE.search(t.text))


# Рваная медитативность (каталог #49): «Короткие. Точные. Отдельные.» Цепочка
# из трёх и более утверждений по 1-3 слова подряд. Не считаются реплики диалога
# (строка с тире или кавычки в начале), восклицания, вопросы, подводки с
# двоеточием, пункты списков и заголовки: там обрывки законны. Порог выбран по
# 400 постам Пикабу: доля обрывков в тексте срабатывала на 5-12% живых текстов
# и отвергнута, цепочка из трёх подряд даёт 4 из 400 (eval/OVERCORRECTION_CHECK.md).
STACCATO_MAX_WORDS = 3
STACCATO_MIN_RUN = 3
_DIALOG_RE = re.compile(r"^\s*[-–—«\"']")
_SKIP_LINE_RE = re.compile(r"^\s*(?:(?:[-*•]|\d+[.)])\s+|#)")


def staccato_runs(text: str) -> tuple[int, int]:
    """(число цепочек, длина самой длинной). Цепочка не переходит через строку."""
    runs: list[int] = []
    for line in text.replace("\\", "").split("\n"):
        if not line.strip() or _SKIP_LINE_RE.match(line):
            continue
        cur = 0
        for s in sentenize(line):
            st = s.text.strip()
            n = _word_count(st)
            if not n:
                continue
            if n <= STACCATO_MAX_WORDS and not _DIALOG_RE.match(st) and st[-1] not in "?!:;":
                cur += 1
            else:
                if cur >= STACCATO_MIN_RUN:
                    runs.append(cur)
                cur = 0
        if cur >= STACCATO_MIN_RUN:
            runs.append(cur)
    return len(runs), max(runs, default=0)


def rhythm(text: str) -> RhythmStats:
    sents = [s.text for s in sentenize(text)]
    lengths = [_word_count(s) for s in sents]
    lengths = [n for n in lengths if n > 0]
    n = len(lengths)
    total_words = sum(lengths)

    runs, longest = staccato_runs(text)
    mean = statistics.mean(lengths) if lengths else 0.0
    stdev = statistics.pstdev(lengths) if n > 1 else 0.0
    cv = (stdev / mean) if mean else 0.0

    return RhythmStats(
        sentences=n,
        words=total_words,
        mean_len=round(mean, 1),
        stdev_len=round(stdev, 1),
        cv_len=round(cv, 3),
        min_len=min(lengths) if lengths else 0,
        max_len=max(lengths) if lengths else 0,
        short_share=round(sum(1 for x in lengths if x < 5) / n, 3) if n else 0.0,
        long_share=round(sum(1 for x in lengths if x > 25) / n, 3) if n else 0.0,
        em_dash=text.count("—"),
        ellipsis=text.count("…") + len(re.findall(r"\.\.\.", text)),
        parentheses=text.count("("),
        questions=sum(1 for s in sents if s.rstrip().endswith("?")),
        staccato_runs=runs,
        staccato_max=longest,
    )


# Эвристические пороги (откалиброваны под русский грубо, см. eval/RESULTS.md).
# cv_len < 0.35 — слишком ровный ритм, признак AI. Человеческий текст обычно > 0.45.
CV_AI_THRESHOLD = 0.35
CV_HUMAN_TARGET = 0.45


def rhythm_verdict(s: RhythmStats, dash_ok: bool = False) -> str:
    """dash_ok=True для жанров, где длинное тире законно (научный,
    юридический, художественный): тогда оно показывается фактом, не ⚠."""
    if s.em_dash > 0 and dash_ok:
        dash = f"тире: {s.em_dash} (законно для жанра)"
    elif s.em_dash > 0:
        dash = f"⚠ {s.em_dash} длинных тире (норма 0)"
    else:
        dash = "✓ тире чисто"
    if s.cv_len < CV_AI_THRESHOLD:
        rhythm_v = f"⚠ ровный ритм (CV={s.cv_len}, цель ≥{CV_HUMAN_TARGET})"
    else:
        rhythm_v = f"✓ ритм рваный (CV={s.cv_len})"
    return f"{rhythm_v}; {dash}"

"""Факт-замок как скрипт: что из фактов исходника дожило до результата.

Скилл обещает переносить числа, даты, имена, названия и ссылки без искажений и
не добавлять новых. Инструкция модели это одно, проверка другое: этот модуль
вынимает из двух текстов «факты» и сравнивает множества. Не семантика и не
фактчек: только сохранность того, что уже было, и появление того, чего не было.

Классы фактов:
- число: любой токен с цифрой (проценты, годы, суммы), нормализован до цифр;
- число словами: крупные числительные («сорок», «тысяча»), их не пересказывают;
- месяц: названия месяцев как замена дате;
- ссылка: URL и адреса вида domain.tld/path;
- код: содержимое инлайн-кода в бэктиках;
- имя: слово с заглавной не в начале предложения (с pymorphy3 точнее: теги
  Name/Surn/Geox/Orgn/Patr и незнакомые словарю слова), плюс любая латиница с
  заглавной («Excel», «GPT-4»).

Мелкие количества («два», «половина», «вдвое») факты мягкие: в русском они
идиоматичны («с одной стороны») и обычно пересказывают число исходника. Они
считаются, но не валят проверку.

Утверждения: слова-кванторы, которые звучат как пафос, а несут факт:
«первый в России», «единственный», «впервые», «рекордный», «до сих пор».
Срезать «первый в России сервис» до «сервис» значит исказить исходник, а
не оживить его. Потерянный квантор попадает в список потерь, появившийся
выносится отдельным предупреждением: кванторы идиоматичны («первый шаг»,
«самое время»), поэтому валить проверку автоматически нельзя, но глазами
такое место обязано проверить.
"""

from __future__ import annotations

import re
from dataclasses import dataclass, field

try:
    import pymorphy3

    _MORPH = pymorphy3.MorphAnalyzer()
except ImportError:  # без словаря сравниваем по основе, грубее, но работает
    _MORPH = None

PROPER_TAGS = {"Name", "Surn", "Geox", "Orgn", "Patr"}

MONTH_RE = re.compile(
    r"\b(январ|феврал|март|апрел|июн|июл|август|сентябр|октябр|ноябр|декабр)[а-я]*\b",
    re.IGNORECASE,
)
URL_RE = re.compile(r"https?://[^\s)>\]»]+|\b[a-z0-9-]+\.(?:ru|com|org|net|io|tech|dev|ai|su|рф)(?:/[^\s)>\]»]*)?",
                    re.IGNORECASE)
CODE_RE = re.compile(r"`([^`\n]+)`")
TOKEN_RE = re.compile(r"[A-Za-z][A-Za-z\d\-]*|[А-Яа-яЁё][А-Яа-яЁё\-]*|\d[\d.,:/-]*")

SOFT_QUANTITIES = {
    "один", "два", "две", "три", "оба", "обе", "пара",
    "второй", "третий",
    "вдвое", "втрое", "дважды", "трижды",
    "половина", "треть", "четверть", "полтора",
}
HARD_NUMERALS = {
    "четыре", "пять", "шесть", "семь", "восемь", "девять", "десять",
    "одиннадцать", "двенадцать", "пятнадцать", "двадцать", "тридцать",
    "сорок", "пятьдесят", "шестьдесят", "семьдесят", "восемьдесят",
    "девяносто", "сто", "двести", "триста", "тысяча", "миллион", "миллиард",
    "десяток", "сотня", "дюжина",
}
# Кванторы-утверждения: громкие слова, за которыми стоит проверяемый факт.
CLAIM_WORDS = {
    "первый", "единственный", "впервые", "самый", "рекордный", "крупнейший",
    "старейший", "никогда", "никто", "навсегда", "беспрецедентный",
}
CLAIM_PHRASE_RE = re.compile(r"\bдо сих пор\b|\bв мире\b|\bв россии\b", re.IGNORECASE)
# Одна сущность под разными именами не считается новым фактом.
ALIASES = {
    "ai": ("искусственный", "интеллект", "ии", "нейросеть", "модель"),
    "ии": ("искусственный", "интеллект", "ai", "нейросеть", "модель"),
    "llm": ("модель", "нейросеть", "ai", "ии"),
}


@dataclass
class Facts:
    hard: set[str] = field(default_factory=set)   # "число:13", "имя:стэнфорд", "ссылка:…"
    soft: set[str] = field(default_factory=set)   # "два", "половина"
    words: set[str] = field(default_factory=set)  # все слова в нормальной форме, для алиасов
    claims: set[str] = field(default_factory=set)  # "утверждение:первый", "утверждение:до сих пор"


@dataclass
class FactsDiff:
    lost: list[str]      # были в исходнике, пропали
    added: list[str]     # появились в результате, в исходнике не было
    kept: int            # жёстких фактов исходника дожило
    soft_added: list[str]
    claims_added: list[str] = field(default_factory=list)  # кванторы, которых в исходнике не было

    @property
    def ok(self) -> bool:
        return not self.added

    def as_dict(self) -> dict:
        return {"ok": self.ok, "lost": self.lost, "added": self.added,
                "kept": self.kept, "soft_added": self.soft_added,
                "claims_added": self.claims_added}


def _norm(word: str) -> str:
    low = word.lower().replace("ё", "е").strip("-")
    if _MORPH is None:
        return low[:5]
    return _MORPH.parse(low)[0].normal_form.replace("ё", "е")


def _sentence_starts(text: str) -> set[int]:
    starts = {0}
    for m in re.finditer(r"[.!?…]\s+|^[>\-*]\s+|«|\n", text):
        starts.add(m.end())
    return starts


def _is_proper(word: str, at_start: bool) -> bool:
    if not word[:1].isupper():
        return False
    if word.isascii():
        return True
    if _MORPH is None:
        return not at_start
    p = _MORPH.parse(word.lower())[0]
    if PROPER_TAGS & set(p.tag.grammemes):
        return True
    if not p.is_known:
        return True
    return not at_start


def extract_facts(text: str) -> Facts:
    f = Facts()
    for m in URL_RE.finditer(text):
        url = re.sub(r"^https?://(?:www\.)?", "", m.group(0).rstrip(".,;:").lower()).rstrip("/")
        f.hard.add("ссылка:" + url)
    for m in CODE_RE.finditer(text):
        f.hard.add("код:" + m.group(1).strip())
    body = CODE_RE.sub(" ", URL_RE.sub(" ", text))
    for m in MONTH_RE.finditer(body):
        f.hard.add("месяц:" + m.group(1).lower())
    for m in CLAIM_PHRASE_RE.finditer(body):
        f.claims.add("утверждение:" + m.group(0).lower().replace("ё", "е"))
    starts = _sentence_starts(body)
    for m in TOKEN_RE.finditer(body):
        tok = m.group(0)
        if tok[0].isdigit():
            digits = re.sub(r"\D", "", tok)
            if digits:
                f.hard.add("число:" + (digits.lstrip("0") or "0"))
            continue
        norm = _norm(tok)
        f.words.add(norm)
        if norm in SOFT_QUANTITIES:
            f.soft.add(norm)
        elif norm in CLAIM_WORDS:
            f.claims.add("утверждение:" + norm)
        elif norm in HARD_NUMERALS:
            f.hard.add("число словами:" + norm)
        elif _is_proper(tok, any(abs(m.start() - s) <= 1 for s in starts)):
            f.hard.add("имя:" + norm)
    return f


def _alias_covered(fact: str, before_words: set[str]) -> bool:
    if not fact.startswith("имя:"):
        return False
    name = fact[4:]
    return any(alias in before_words for alias in ALIASES.get(name, ()))


def diff_facts(before: str, after: str) -> FactsDiff:
    b, a = extract_facts(before), extract_facts(after)
    lost = sorted(b.hard - a.hard) + sorted(b.claims - a.claims)
    added = sorted(x for x in a.hard - b.hard if not _alias_covered(x, b.words))
    return FactsDiff(lost=lost, added=added, kept=len(b.hard & a.hard),
                     soft_added=sorted(a.soft - b.soft),
                     claims_added=sorted(a.claims - b.claims))


def facts_verdict(d: FactsDiff) -> str:
    if d.added:
        return f"✗ новых фактов без источника: {len(d.added)} (выдумка хуже канцелярита)"
    if d.lost:
        return f"⚠ факты исходника на месте, но {len(d.lost)} потеряно: проверьте, намеренно ли"
    if d.claims_added:
        return (f"⚠ факты целы, но появилось утверждений без источника: {len(d.claims_added)} "
                "(«впервые», «единственный» это факт, а не украшение)")
    return f"✓ факт-замок цел: {d.kept} фактов исходника перенесено, новых нет"

"""Границы чужого текста в Markdown: код, цитаты, короткие «ёлочки».

Сканер измеряет слова автора. Листинг кода, markdown-цитата через «>» и короткая
цитата в ёлочках это чужие слова, их баны и маркеры не в счёт. Два релиза
подряд границы чинились регулярками по одному примеру, и каждый раз соседний
вариант той же ошибки оставался (ограда внутри строки кода, закрытие оградой
длиннее открывающей, продолжение цитаты без «>»). Здесь один построчный разбор
состояния по правилам CommonMark и таблица тестов на варианты в
scripts/test_markers.py.

Две проекции одного текста:
- lexical: чужое заменено заглушкой GAP посимвольно, переводы строк на месте.
  Смещения и номера строк совпадают с исходником, фразовые регексы не
  склеивают слова через заглушку (она не буква).
- prose: чужое вырезано целиком. Для ритма, морфологии и структуры: заглушки
  ломали бы длину предложений и подсчёт абзацев.

Правила:
- Ограда кода: 3+ обратных кавычек или тильд с отступом до 3 пробелов в начале
  строки. Закрывает ограда того же символа НЕ КОРОЧЕ открывающей. Кавычки внутри
  строки кода оградой не являются. Незакрытая ограда не маскируется вовсе:
  для сканера ложное срабатывание дешевле спрятанного абзаца.
- Цитата: строка с «>» в начале (отступ до 3 пробелов). Ленивое продолжение:
  следующие непустые строки без «>» остаются цитатой, пока не встретится
  пустая строка, заголовок, пункт списка или ограда.
- Инлайн-код: серия обратных кавычек закрывается серией той же длины в
  пределах строки (`x`, ``a`b``).
- Короткая цитата в ёлочках (до QUOTE_MAX_WORDS слов) заглушается только в
  lexical: так цитируют слово или оборот. Длинная остаётся под сканером, это
  прямая речь или пересказ, её маркеры на совести автора. В prose ёлочки не
  трогаем, они внутри предложений автора.
"""

from __future__ import annotations

import re

GAP = "·"
QUOTE_MAX_WORDS = 12

_FENCE_OPEN = re.compile(r"^ {0,3}(`{3,}|~{3,})(.*)$")
_FENCE_CLOSE = re.compile(r"^ {0,3}(`{3,}|~{3,})\s*$")
_QUOTE_LINE = re.compile(r"^ {0,3}>")
# Строки, которые прерывают ленивое продолжение цитаты (CommonMark 5.1):
# заголовок, пункт списка, горизонтальная линия, ограда.
_BLOCK_START = re.compile(r"^ {0,3}(?:#{1,6}\s|[-*+]\s|\d{1,9}[.)]\s|(?:-{3,}|\*{3,}|_{3,})\s*$|`{3,}|~{3,})")
_INLINE_CODE = re.compile(r"(`+)(?!`)([^`\n]+?)\1(?!`)")
_QUOTE_MARKS = re.compile(r"«[^«»]*»")


def _blank(s: str) -> str:
    return re.sub(r"[^\n]", GAP, s)


def _fence_ranges(lines: list[str]) -> list[tuple[int, int]]:
    """Пары (первая, последняя) строк закрытых блоков кода, включая ограды."""
    ranges: list[tuple[int, int]] = []
    i = 0
    while i < len(lines):
        m = _FENCE_OPEN.match(lines[i])
        # Инфо-строка ограды из кавычек не может содержать кавычки (CommonMark).
        if not m or (m.group(1)[0] == "`" and "`" in m.group(2)):
            i += 1
            continue
        ch, need = m.group(1)[0], len(m.group(1))
        j = i + 1
        while j < len(lines):
            c = _FENCE_CLOSE.match(lines[j])
            if c and c.group(1)[0] == ch and len(c.group(1)) >= need:
                break
            j += 1
        if j >= len(lines):
            i += 1  # незакрытая ограда: обычная строка
            continue
        ranges.append((i, j))
        i = j + 1
    return ranges


def _quote_lines(lines: list[str], in_code: set[int]) -> set[int]:
    quoted: set[int] = set()
    inside = False
    for i, line in enumerate(lines):
        if i in in_code:
            inside = False
            continue
        if _QUOTE_LINE.match(line):
            inside = True
            quoted.add(i)
        elif inside and line.strip() and not _BLOCK_START.match(line):
            quoted.add(i)  # ленивое продолжение абзаца цитаты
        else:
            inside = False
    return quoted


def _classify(text: str) -> tuple[list[str], set[int], set[int]]:
    lines = text.split("\n")
    in_code: set[int] = set()
    for a, b in _fence_ranges(lines):
        in_code.update(range(a, b + 1))
    return lines, in_code, _quote_lines(lines, in_code)


def _blank_short_quote(m: re.Match[str]) -> str:
    inner = m.group(0)[1:-1]
    return _blank(m.group(0)) if len(inner.split()) <= QUOTE_MAX_WORDS else m.group(0)


def mask_foreign(text: str) -> str:
    """lexical: код, цитаты и короткие ёлочки заглушены, смещения сохранены."""
    lines, in_code, quoted = _classify(text)
    out: list[str] = []
    for i, line in enumerate(lines):
        if i in in_code or i in quoted:
            out.append(_blank(line))
        else:
            out.append(_INLINE_CODE.sub(lambda m: _blank(m.group(0)), line))
    return _QUOTE_MARKS.sub(_blank_short_quote, "\n".join(out))


def strip_foreign(text: str) -> str:
    """prose: код и цитаты вырезаны, инлайн-код удалён, ёлочки на месте."""
    lines, in_code, quoted = _classify(text)
    kept = [_INLINE_CODE.sub("", line) for i, line in enumerate(lines)
            if i not in in_code and i not in quoted]
    return "\n".join(kept)

"""Лексические маркеры AI-текста: HARD BANS и быстрый сканер.

Вордлисты вынесены один-в-один из прозы скилла: HARD BANS — из SKILL.md
(раздел «Жёсткие запреты»), категории сканера — из references/catalog.md
(раздел «Быстрый сканер: слова-маркеры AI», списки вынесены туда в v3.15.0).
Это детерминированная, грепабельная половина
режима «Аудит» — то, что не требует LLM. Семантика (кальки, ирония, translationese)
тут не ловится принципиально, для неё нужен сам скилл.

Источник правды — SKILL.md и references/catalog.md. При обновлении
банов/маркеров правь оба файла;
scripts/lint_skill.py проверяет, что списки не разошлись по числу пунктов.
"""

from __future__ import annotations

import re
from dataclasses import dataclass, field

# --- HARD BANS -----------------------------------------------------------
# 20 конструкций с абсолютным запретом. Каждая — (имя, regex). Regex
# регистронезависимый, по словоформам где это безопасно.
HARD_BANS: list[tuple[str, str]] = [
    ("Не просто X, а Y", r"\bне\s+просто\b[^.!?]{1,40}?\bа\b"),
    ("Не только X, но и Y", r"\bне\s+только\b[^.!?]{1,40}?\bно\s+и\b"),
    ("В современном мире", r"\bв\s+современном\s+мире\b"),
    ("Стоит отметить, что", r"\bстоит\s+отметить\b"),
    # Расширен по шахте LLMTrace (русские модели против людей тех же тем):
    # «важно помнить, что» 155 машинных документов против 3 человеческих,
    # «важно отметить, что» 144 против 1; в AINL у людей 0 и 2 из 8 769.
    ("Важно понимать/помнить/отметить, что", r"\bважно\s+(?:понимать|помнить|отметить)\b"),
    # Только единственное число (как в SKILL.md HARD BAN). Множественные формы
    # «данные/данных/данным/данными» совпадают с существительным «данные» (data)
    # и давали ложные срабатывания на ML/статистических текстах.
    ("Данный/Данная/Данное", r"\bданн(ый|ая|ое|ого|ой|ом|ую)\b"),
    ("Является", r"\bявля(ется|ются)\b"),
    ("Играет важную/ключевую роль", r"\bигра(ет|ют)\s+(важн\w+|ключев\w+)\s+роль\b"),
    ("Можно с уверенностью сказать", r"\bможно\s+с\s+уверенностью\s+сказать\b"),
    # «Таким образом» банится только как ВВОДНЫЙ коннектор-вывод (начало
    # предложения либо обособлен запятыми с запятой следом): «...рынки. Таким
    # образом, ...». Омонимичное обстоятельство образа действия «...таким
    # образом, что...» (= «такой манерой») — живая речь, не AI-клише, под бан не
    # идёт: перед ним стоит слово, а не граница предложения/запятая. На корпусе
    # сужение не теряет ни одного AI-вхождения (все 7/7 raw — вводные «. Таким
    # образом,»), но снимает ложные срабатывания на художественной прозе.
    # «Подводя итог» однозначно итожащее — остаётся широким.
    ("Подводя итог / Таким образом",
     r"\bподводя\s+итог\b|(?:^|[.!?…:;]\s+|\n\s*(?:[-*•]\s*)?|,\s*)таким\s+образом\s*,"),
    ("Длинное тире", r"—"),
    # Короткое тире «–» (U+2013). Отдельным баном, потому что промахивается мимо
    # регулярки на «—», а семейство gemma подменяет им длинное: парный замер на
    # одних и тех же постах дал человека 6% против 80% у gemma3:4b и gemma3:27b,
    # 64% у gemma3:1b. У остальных семейств сигнала нет (qwen 6-10%, Opus 0%),
    # то есть это признак семейства, а не машинности вообще, но по силе лифта
    # он обходит почти весь каталог. В русской типографике «–» законно только в
    # числовых диапазонах, их и исключаем.
    ("Короткое тире", r"(?<!\d)\s*–|–\s*(?!\d)"),
    # Ложный диапазон — только несвязанные понятия. Семантику «несвязанности»
    # регекс не проверит, поэтому исключаем заведомо легитимные классы:
    # числа («от 10 до 15»), имена собственные («от Москвы до Твери» — операнды
    # проверяются регистрозависимо через (?-i:...)), повтор слова («от зари до зари»).
    ("от X до Y (ложный диапазон)",
     r"\bот\s+(?-i:([а-яё]+))\s+до\s+(?-i:(?!\1\b)[а-яё]+)\b"),
    ("В условиях [прил.] [сущ.]", r"\bв\s+условиях\s+\w+"),
    ("Погрузимся / посмотрим поближе", r"\b(погрузимся|посмотрим\s+\w+\s+поближе|давайте\s+посмотрим)\b"),
    ("И вот здесь начинается самое интересное", r"\bвот\s+(здесь|тут)\s+начинается\s+самое\s+интересное\b"),
    ("Раскрыть потенциал", r"\bраскры(ть|ва\w+)\s+потенциал\b"),
    ("Вывести на новый уровень", r"\bвыв(ести|одит)\s+на\s+новый\s+уровень\b"),
    ("Комплексный подход/решение", r"\bкомплексн(ый|ое|ого|ым)\s+(подход\w*|решени\w+)\b"),
    ("В связи с этим", r"\bв\s+связи\s+с\s+этим\b"),
    # «Возможности» добавлены после прогона eval/mine_patterns.py: это самый
    # частый вариант формулы, и он проходил мимо бана. На AINL-Eval 0.07% у
    # людей против 2.43% у моделей (llama 5.3%), то есть разделение сильнее,
    # чем у «горизонтов».
    ("Открывает новые горизонты/перспективы/возможности",
     r"\bоткрыва(ет|ют)\s+новые\s+(горизонт\w+|перспектив\w+|возможност\w+)\b"),
]

# --- Быстрый сканер: категории слов-маркеров -----------------------------
# Лексический подсет категорий «Быстрого сканера» каталога (нелексические —
# ритм, структура — живут в других модулях: burstiness.py, structure.py).
# Семантические категории сканера («Фигуративный ноль», «Пустая образность»)
# кодом не покрываются нигде: это чисто смысловые проверки, их оценивает
# только LLM-слой аудита по каталогу. Элемент — либо
# фраза для подстрочного поиска (регистронезависимо; часть фраз — основы, чтобы
# ловить словоформы), либо строка с префиксом "re:" (регекс), либо пара
# (человекочитаемая метка, регекс) — метка идёт в отчёт вместо регекса.
SCANNER: dict[str, list[str | tuple[str, str]]] = {
    "Канцелярит": [
        "осуществлени", "реализаци", "внедрени", "оптимизаци", "функционировани",
        "взаимодействи", "в рамках", "в целях", "в контексте", "на основе",
        "посредством", "в соответствии с",
        # Найдено шахтой (eval/mine_patterns.py), доли документов на AINL-Eval
        # человек/AI: «внимание уделяется» 1.3/7-18%, «внимание уделено»
        # 0.8/5-30%, «посвящена анализу» 2.7/10-29%. Все три держатся и на
        # невиданной модели (unknown 8-16%). Категория глушится в академическом
        # жанре, поэтому научной прозе они не мешают.
        "внимание уделяется", "внимание уделено",
        ("посвящена анализу/изучению/разработке",
         r"посвящен[ао]\s+(анализ\w+|изучени\w+|разработк\w+|рассмотрени\w+)"),
    ],
    "Кальки": [
        ("является", r"\bявля(ется|ются)\b"),
        "стоит отметить", "важно понимать", "можно сказать",
        "что касается", "в то время как", "с другой стороны", "тем не менее",
        "несмотря на то что",
        "стоит помнить", "следует учитывать", "необходимо отметить",
        # Калька с «this study focuses on». Самые чистые ложные срабатывания из
        # всей находки: 0.01% на людях против 2.2-2.9% у моделей. На невиданной
        # модели не держится (0.18%), то есть это привычка семейств, а не след
        # машины вообще, поэтому мягкий маркер, а не бан.
        ("исследование фокусируется на",
         r"(исследовани\w+|работ\w+|стать\w+)\s+фокусиру\w+\s+на"),
    ],
    "Раздувание": [
        "ключев", "важнейш", "значительн", "огромн", "колоссальн", "переломн",
        "фундаментальн", "невозможно переоценить", "играет роль",
        # «важный шаг (на пути) к»: LLMTrace 156 машинных документов против 3
        # человеческих, AINL 56 против 2. «Шаг вперёд» и «большой шаг» не
        # разделяют, в маркер не входят.
        ("важный шаг", r"\bважн\w+\s+шаг\w*"),
    ],
    "Формула-выводы": [
        # Вводный коннектор-вывод, суженный так же, как одноимённый хард-бан:
        # обстоятельство «устроен таким образом, что...» — не маркер.
        ("таким образом, (вводное)",
         r"(?:^|[.!?…:;]\s+|\n\s*(?:[-*•]\s*)?|,\s*)таким\s+образом\s*,"),
        "подводя итог", "в заключение", "можно сделать вывод",
        "суммируя вышесказанное", "на основании вышеизложенного",
    ],
    "Чатбот": [
        "конечно!", "отличный вопрос", "давайте разберёмся", "давайте разберемся",
        "рад помочь", "надеюсь это было полезно", "с удовольствием",
    ],
    # «это не X, это Y» — конструкция, а не любое отрицание: «это не может не
    # радовать» — живая речь, маркером не считается.
    "Параллелизмы": ["не просто", "не только",
                     ("это не X, это Y", r"это\s+не\s+[^.!?\n]{1,40}[,—:-]\s*это\b")],
    "Вводные-открытия": [
        "в современном мире", "в эпоху", "не секрет что", "не секрет, что",
        "всё чаще", "все чаще", "по мнению экспертов", "специалисты отмечают",
    ],
    "Модальные хеджи": [
        "может стать", "может повлиять", "может быть полезн", "способен обеспечить",
        "призван решить", "позволяет достичь",
    ],
    "Мотивационные клише": [
        "раскрыть потенциал", "погрузимся", "вывести на новый уровень",
        "открывает новые горизонты", "открывает новые возможности",
        "расширить границы", "комплексный подход",
    ],
    "Контекстуализаторы": [
        "в условиях", "в свете", "на фоне", "с учётом", "с учетом",
        "принимая во внимание", "в связи с этим",
    ],
    "Маркетинговые штампы": [
        "связь с аудиторией", "доверительные отношения", "ключевой момент",
        "ключевая роль", "индивидуальный подход", "инновационное решение",
    ],
    "Псевдо-сократические": [
        "зачем? потому что", "и что? а то", "почему? сейчас расскажу",
    ],
    "Авторитетные трюизмы": [
        "вот ключевой вывод", "самое важное — это", "самое важное - это",
        "первый шаг — это", "первый шаг - это", "по своей сути", "в конечном счёте",
        "в конечном счете",
    ],
    "Псевдо-терапевтические": [
        "ты не ошибаешься", "ты имеешь право", "тихое подтверждение",
        "это не слабость", "ты настоящий", "сам факт этого",
    ],
    # Паттерн #54 (приоритет A): текст присваивает себе добродетель честности
    # вместо предъявления фактов. Гасим класс ложных срабатываний из каталога:
    # одиночное разговорное «честно» / «честно говоря» (частица живой речи,
    # паттерн #32) и жанровый заголовок «честный обзор» (человеческая конвенция
    # кликбейта) НЕ ловятся — голого «честно» и «честного обзора» в списке нет,
    # только фразы самомаркировки. Остаточный риск: буквальное «без воды»
    # (кулинария, химия) и «объективный разбор» о чужом тексте — редки, гасятся
    # шкалой вердикта (одиночный маркер не валит текст). Каталожный порог
    # «2+ на текст или маркировка в заголовке секции» зафиксирован здесь
    # комментарием: архитектура SCANNER считает поштучно, плотностных порогов
    # на категорию у неё нет.
    "Самомаркировка честности": [
        ("честный список", r"\bчестн(?:ый|ого|ому|ым|ом)\s+спис\w*\b"),
        ("буду (с вами) откровенен", r"\bбуду\s+(?:с\s+(?:вами|тобой)\s+)?откровен\w*\b"),
        "без прикрас",
        ("без воды", r"\bбез\s+воды\b"),
        ("объективный разбор", r"\bобъективн\w+\s+разбор\w*\b"),
        ("это не очередной", r"\bэто\s+не\s+очередн\w*\b"),
    ],
    "Эмодзи-декор": ["⚡", "✨", "🎯", "🔥", "💡"],
    # Однозначные улики подмены символов (SKILL.md, «Технические маркеры»):
    # латинские гомоглифы внутри кириллического слова и невидимые символы.
    # Легитимная латиница (IT, web, URL) кириллицей с двух сторон не окружена.
    "Технические маркеры": [
        ("латиница внутри кириллического слова", r"(?<=[а-яё])[a-z](?=[а-яё])"),
        # zero-width (ZWSP/ZWNJ/ZWJ/BOM) + word joiner, Mongolian vowel
        # separator, bidi-метки и изоляторы: клавиатурой не набираются,
        # в живом русском тексте не встречаются. Плюс узкий неразрывный
        # пробел U+202F: его ставят o3/o4-mini и GPT-5 перед единицами, на
        # LLMTrace 0 из 6 392 человеческих текстов. Обычный U+00A0 сюда
        # НЕ входит: у людей он в 10 раз чаще (вёрстка, редактура).
        ("невидимые символы (zero-width, bidi)",
         "[​‌‍⁠᠎‎‏"
         "‪-‮⁦-⁩؜ ]"),
    ],
    # Паттерн #55: подлежащее-предмет при глаголе намерения. Английские
    # источники описывают то же самое как смену AI-словаря на emphasizing /
    # highlighting / showcasing (Wikipedia AI Cleanup, обновление 2026).
    "Неодушевлённый субъект": [
        ("предмет или абстракция подчёркивает/демонстрирует",
         r"\b(исследовани\w+|работ[аы]|стать\w+|проект\w*|платформ\w+|систем\w+|"
         r"решени\w+|компани\w+|здани\w+|документ\w*|отчёт\w*|инициатив\w+|"
         r"технологи\w+|подход\w*)\s+"
         r"(подчёркива\w+|демонстрир\w+|отража\w+|обеспечива\w+|иллюстрир\w+|"
         r"символизир\w+|подтвержда\w+)\b"),
    ],
    # Паттерн #58: формула 2026 года «No X. No Y. Just Z.» в русском изводе.
    "Триада-отрицание": [
        ("Без X. Без Y. Только Z.",
         r"(?:^|[.!?…\n]\s*)(?:без|ни)\s+[^.!?\n]{1,40}[.!?]\s+(?:без|ни)\s+"
         r"[^.!?\n]{1,40}[.!?]\s+(?:только|просто|лишь)\b"),
    ],
    # Паттерн #59 (категория N, дискурсный слой): нарратор проговаривает мораль
    # прямым текстом. StoryScope (arXiv:2604.03136v6, COLM 2026), параллельный
    # корпус 61 608 историй: явная мораль у ИИ в 77% текстов против 52% у
    # людей. Разрыв в полтора раза, то есть половина людей делает то же самое:
    # маркер мягкий, не бан, и один его хит текст не валит.
    # Кодом ловится только узкий лексический подкласс - шаблонные формулы
    # морали; остальная категория N нелексическая и оценивается LLM-слоем
    # аудита по каталогу, как «Фигуративный ноль».
    # Три сужения против ложных срабатываний на живой прозе:
    # 1) указательное «этой/сей/эта» обязательно - иначе под маркер уходят
    #    разбор басни («мораль истории про лису») и публицистический оборот
    #    «история учит нас осторожности», который человек пишет свободно;
    # 2) окончания после «истори» перечислены явно - \w цеплял «историк»
    #    («наш историк учит нас работать с источниками»);
    # 3) голые «мораль проста/такова» считаются только последней фразой
    #    текста: в середине это разговорная связка («в басне мораль проста,
    #    а исполнение так себе»), в финале - тот самый дискурсный признак.
    "Финальная мораль": [
        ("мораль этой истории",
         r"\bмораль\s+(?:этой|всей\s+этой|сей)\s+истори(?:и|ю|ей)\b"),
        ("эта история учит нас",
         r"\b(?:эта|вся\s+эта)\s+истори(?:я|и)\s+(?:учит|научила|учила)\s+(?:нас|нам)\b"),
        ("эта история о том, что",
         r"\bэта\s+истори(?:я|и)\s+о\s+том,\s+что\b"),
        ("мораль проста (последней фразой)",
         r"[.!?…]\s+мораль\s+(?:проста|такова)\b[^.!?]{0,60}[.!?]\s*$"),
    ],
    # Технические следы копирования из интерфейса чат-бота. Однозначные улики:
    # в человеческом тексте не встречаются.
    # Префикс "re:" = регулярное выражение, остальное — подстрока.
    "Артефакты копипасты": [
        ":contentReference", "oai_citation", "utm_source=chatgpt.com",
        "utm_source=openai", "grok_card://", "attached_file://",
        "vertexaisearch.cloud.google.com/grounding-api-redirect",
        "](sandbox:/mnt/data/", "attributableIndex",
        r"re:oaicite:\d+",
        r"re:turn\d+(?:search|fetch|file)\d+",          # turnNsearchN и родня
        r"re:citeturn\d+[a-z]+\d+",                     # слитная метка цитаты
        r"re:【\d+(?::\d+)?†source】",                    # OpenAI Assistants
        r"re:\[citation:\d+\]",                         # Perplexity-стиль
        "re:[\ue200-\ue204]",                        # невидимые разделители цитат ChatGPT
        r"re:</?think>",                                # остатки рассуждения DeepSeek и др.
        # Замечены в 2026 (Wikipedia AI Cleanup, разделы про артефакты разметки):
        r"re::::writing\{variant=",                     # обёртка документа, с июня 2026
        r"re:\[cite:\s*\d+\]",                          # метка цитаты Gemini
        r"re:\[span_\d+\]\(start_span\)",               # обёртка фрагмента Gemini
        "grok_render_citation_card_json",               # карточка цитаты Grok
    ],
}

@dataclass
class MarkerHit:
    category: str
    marker: str
    count: int
    positions: list[int] = field(default_factory=list)


def _find_all(text: str, needle_regex: str) -> list[int]:
    return [m.start() for m in re.finditer(needle_regex, text, re.IGNORECASE)]


def scan_hard_bans(text: str) -> list[MarkerHit]:
    """Находит конструкции из HARD BANS. Любое попадание = провал."""
    hits: list[MarkerHit] = []
    for name, pat in HARD_BANS:
        pos = _find_all(text, pat)
        if pos:
            hits.append(MarkerHit("HARD BAN", name, len(pos), pos))
    return hits


# Частотные пороги из SKILL.md: маркер банится не с первого вхождения, а по
# плотности. «Является» — легитимная связка в меру (термины, определения):
# таблица HARD BANS задаёт «>1 раз на 500 слов». Одиночное вхождение остаётся
# мягким маркером («Кальки»), scan_hard_bans его по-прежнему находит.
FREQ_BANS: dict[str, int] = {"Является": 500}


# --- Почему тире остаётся баном, хотя частоты говорят обратное -------------
# Класс ошибки, который тут однажды был допущен и откачен в тот же день.
#
# Если считать ДОЛЮ ДОКУМЕНТОВ в несопряжённых корпусах, тире выглядит признаком
# человека: AINL человек 4.8% против 0.0-0.9% у моделей, M4 человек 42.3% против
# 3.3%, Пикабу человек 14.0%. Вывод напрашивается сам, и он неверный по двум
# причинам сразу: человеческие половины там это изданная вычитанная проза, где
# тире ставит редактор, а машинные половины сделаны генераторами 2023-2024 годов.
#
# Продуктовый вопрос звучит не так. Пользователь отдаёт модели СВОЙ текст, и
# важно, что она с ним делает. Это парный замер на одних и тех же постах, и он
# даёт противоположный ответ (доля пар, где тире не было у человека, но
# появилось у машины):
#
#   Qwen3-4B-heretic   45 из 45      человек 10% -> машина 100%
#   qwen2.5:7b         19 из 31      человек 11% -> машина  66%
#   qwen3-vl:4b         5 из 9       человек 10% -> машина  60%
#   Opus 5              4 из 15      человек  0% -> машина  27%
#   gemma3:27b          4 из 45      человек 10% -> машина  14%
#
# Семейство gemma тире почти не добавляет, но подменяет его коротким (см. ниже).
#
# Ложные срабатывания на изданной прозе при этом реальны, и лечатся они не
# отменой бана, а жанровым фильтром: в academic и legal тире уже снимается.
FREQ_BANS_NOTE = "см. комментарий выше про парный замер"


# --- Жанровый фильтр ------------------------------------------------------
# Часть банов в отдельных жанрах не признак машины, а норма регистра. Для
# академического текста это измерено: прогон по AINL-Eval 2025 (35 158 русских
# научных аннотаций с разметкой human / gpt-4-turbo / gemma-2-27b /
# llama-3.3-70b) дал 35.9% документов с баном у ЛЮДЕЙ против 26.1-35.8% у
# моделей: маркеры не разделяли классы вовсе. «Является» сработало на 8.0%
# человеческих текстов и 0.1-3.0% машинных, длинное тире на 4.8% у людей и
# 0.0-0.9% у моделей. С фильтром ниже человеческие срабатывания падают до 4.2%.
# Цифры и метод: eval/ainl_calibration.py, SOURCES.md.
#
# Жанры legal и fiction фильтруются по тем же правилам, что записаны в разделе
# «Ложные срабатывания» SKILL.md; корпусной проверки под них у нас пока нет.
#
# Жанр news (новости и энциклопедические статьи) измерен на русской части
# LLMTrace, домены news + factual, 1 697 человеческих и 2 080 машинных
# документов: глушится всё, у чего лифт (доля у машин / доля у людей) ниже 1,5.
# Длинное тире там у 37,5% людей (лифт 0,7), «данный» у 6,2% (0,8), короткое
# тире у 8,0% (0,9), «является» у 15,8% (1,5), канцелярит у 14,0% (0,9), кальки
# у 20,1% (1,4). Строгий режим ловит 55,7% людей против 58,7% машин, то есть не
# различает их; с профилем news 10,1% против 20,5%. Цифры: eval/llmtrace_calibration.py.
GENRE_MUTED_BANS: dict[str, set[str]] = {
    "academic": {
        "Является", "Длинное тире", "Короткое тире", "Данный/Данная/Данное",
        "В условиях [прил.] [сущ.]", "Подводя итог / Таким образом",
        "В связи с этим",
    },
    "legal": {
        "Является", "Данный/Данная/Данное", "В условиях [прил.] [сущ.]",
        "В связи с этим", "Длинное тире", "Короткое тире",
    },
    "fiction": {
        "Длинное тире", "Короткое тире", "от X до Y (ложный диапазон)",
        "Не только X, но и Y",
        "Не просто X, а Y",
    },
    "news": {
        "Является", "Длинное тире", "Короткое тире", "Данный/Данная/Данное",
        "от X до Y (ложный диапазон)",
    },
}

GENRE_MUTED_CATEGORIES: dict[str, set[str]] = {
    "academic": {"Канцелярит", "Кальки", "Контекстуализаторы", "Формула-выводы"},
    "legal": {"Канцелярит", "Кальки", "Контекстуализаторы"},
    "fiction": {"Параллелизмы"},
    "news": {"Канцелярит", "Кальки", "Контекстуализаторы"},
}

GENRES = ("marketing", "academic", "legal", "fiction", "news")


# --- Что проверено корпусом, а что нет ------------------------------------
# Каталог собирался вручную, и до 2026 года ни один его пункт не был проверен
# на том, отличает ли он вообще человека от машины. Теперь часть проверена, и
# честнее показывать разницу, чем выдавать всё за одинаково обоснованное.
#
# Ниже категории, которые разделяют классы В ДВУХ РАЗНЫХ ДОМЕНАХ сразу: на
# научных аннотациях (AINL-Eval 2025, 35 158 текстов, генераторы gpt-4-turbo,
# gemma-2-27b, llama-3.3-70b) и на смешанном регистре (M4-ru, 11 518 текстов,
# генераторы gpt-3.5-turbo и davinci-003). Число это лифт, отношение частоты у
# машины к частоте у человека; всё, что ниже 1, работает против нас.
#
# Остальные пункты каталога либо не проверялись, либо переворачиваются при
# смене домена: «Является» даёт 0.1 на научном тексте и 4.5 на смешанном,
# «Данный» 0.9 и 3.1, кальки 0.3 и 2.0. Канцелярит не разделяет ни там, ни там,
# хотя в каталоге назван главным маркером. Это не повод их выбрасывать: маркер
# без указания домена просто бессмыслен, о чём написано в SOURCES.md.
CROSS_DOMAIN_VERIFIED: dict[str, tuple[float, float]] = {
    # категория или бан: (лифт на AINL, лифт на M4)
    "Играет важную/ключевую роль": (5.7, 9.4),
    "Мотивационные клише": (2.8, 4.0),
    "Неодушевлённый субъект": (4.4, 2.7),
    "Комплексный подход/решение": (3.0, 2.8),
    "Модальные хеджи": (2.6, 2.9),
    "Раздувание значимости": (1.8, 1.4),
}


def mute_by_genre(hits: list[MarkerHit], genre: str | None,
                  muted: dict[str, set[str]]) -> list[MarkerHit]:
    """Снимает маркеры, законные для жанра. Без жанра ничего не снимает:
    умолчание остаётся строгим (маркетинг и блоги, под них калибровка)."""
    names = muted.get(genre or "", set())
    return [h for h in hits if h.marker not in names and h.category not in names]


def effective_hard_bans(hits: list[MarkerHit], words: int) -> list[MarkerHit]:
    """Хард-баны после частотных порогов: то, что реально штрафуется/валит exit.

    Для маркеров из FREQ_BANS попадание остаётся баном только при двух и более
    вхождениях с плотностью выше 1 на N слов. Остальные баны проходят как есть.
    """
    out: list[MarkerHit] = []
    for h in hits:
        per = FREQ_BANS.get(h.marker)
        if per and (h.count < 2 or h.count <= words / per):
            continue
        out.append(h)
    return out


def scan_markers(text: str) -> list[MarkerHit]:
    """Прогоняет лексические категории быстрого сканера (SCANNER). Возвращает только попадания.

    Элемент с префиксом "re:" трактуется как регулярное выражение,
    остальные — как литеральная подстрока (регистронезависимо).
    """
    hits: list[MarkerHit] = []
    for cat, phrases in SCANNER.items():
        for phrase in phrases:
            if isinstance(phrase, tuple):
                label, pat = phrase
            elif phrase.startswith("re:"):
                label, pat = phrase[3:], phrase[3:]
            else:
                label, pat = phrase, re.escape(phrase)
            pos = _find_all(text, pat)
            if pos:
                hits.append(MarkerHit(cat, label, len(pos), pos))
    return hits


def marker_verdict(marker_hits: list[MarkerHit]) -> str:
    """Шкала из SKILL.md: 0-2 чисто, 3-5 подозрительно, 6+ AI.
    Артефакт копипасты — однозначная улика: вердикт сразу, без шкалы."""
    if any(h.category == "Артефакты копипасты" for h in marker_hits):
        return "артефакты копипасты из чат-бота — текст вставлен из ответа ИИ"
    total = sum(h.count for h in marker_hits)
    if total <= 2:
        return f"{total} — скорее всего чистый текст"
    if total <= 5:
        return f"{total} — подозрительно"
    return f"{total} — AI-генерация с высокой вероятностью"

"""MCP-сервер humanizer-ru: сканер и факт-замок по stdio.

Без зависимостей сверх самого пакета: JSON-RPC 2.0 построчно через stdin и
stdout, как требует транспорт stdio в MCP. Два инструмента:

  scan_text      балл чистоты, штрафы, запреты и маркеры с позициями
  compare_texts  «было и стало» плюс факт-замок между исходником и правкой

Запуск: ru-humanizer-mcp (точка входа пакета ru-humanizer) или
python -m humanizer_metrics.mcp_server. Логи только в stderr: stdout занят
протоколом.
"""

from __future__ import annotations

import json
import sys
from importlib import metadata

from . import analyze, cleanliness_score, diff_facts, facts_verdict
from .markers import (GENRE_MUTED_BANS, GENRE_MUTED_CATEGORIES, GENRES,
                      effective_hard_bans, mute_by_genre)

PROTOCOL_VERSION = "2025-06-18"
SERVER_NAME = "humanizer-ru"

GENRE_SCHEMA = {
    "type": ["string", "null"],
    "enum": [*GENRES, None],
    "description": "Жанр текста. По умолчанию marketing (строгий режим). "
                   "academic, legal, fiction и news снимают маркеры, законные для регистра.",
}

TOOLS = [
    {
        "name": "scan_text",
        "title": "Проверить русский текст на следы нейросети",
        "description": (
            "Балл чистоты 0-100 (85 и выше чисто, 60-84 точечная правка, ниже 60 рерайт), "
            "штрафы с причинами, жёсткие запреты и мягкие маркеры с позициями в тексте, "
            "ритм предложений, морфология и структура. Не детектор авторства: показывает, "
            "что править."
        ),
        "inputSchema": {
            "type": "object",
            "properties": {
                "text": {"type": "string", "description": "Русский текст для проверки"},
                "genre": GENRE_SCHEMA,
            },
            "required": ["text"],
        },
    },
    {
        "name": "compare_texts",
        "title": "Сравнить исходник и правку",
        "description": (
            "Балл «было и стало» с дельтой и факт-замок: числа, даты, имена, ссылки и код "
            "исходника должны дожить до правки, а новых появиться не должно. Отдельно "
            "кванторы («впервые», «единственный», «в России»), возникшие без источника."
        ),
        "inputSchema": {
            "type": "object",
            "properties": {
                "before": {"type": "string", "description": "Текст до правки"},
                "after": {"type": "string", "description": "Текст после правки"},
                "genre": GENRE_SCHEMA,
            },
            "required": ["before", "after"],
        },
    },
]


def _version() -> str:
    try:
        return metadata.version("ru-humanizer")
    except metadata.PackageNotFoundError:
        return "dev"


def _hits(hits) -> list[dict]:
    return [{"category": h.category, "name": h.marker, "count": h.count,
             "positions": list(h.positions)} for h in hits]


def scan(text: str, genre: str | None = None) -> dict:
    """Тот же расчёт, что в scan.py: балл по жанру, частотные баны и жанровый фильтр."""
    genre = genre or "marketing"
    if genre not in GENRES:
        raise ValueError(f"неизвестный жанр {genre!r}, допустимы: {', '.join(GENRES)}")
    rep = analyze(text)
    sc = cleanliness_score(rep, genre)
    bans = mute_by_genre(effective_hard_bans(rep.hard_bans, rep.rhythm.words),
                         genre, GENRE_MUTED_BANS)
    soft = mute_by_genre(rep.markers, genre, GENRE_MUTED_CATEGORIES)
    return {
        "score": sc.score,
        "band": sc.band,
        "penalties": [{"reason": r, "points": p} for r, p in sc.penalties],
        "notes": list(sc.notes),
        "genre": genre,
        "words": rep.rhythm.words,
        "hard_bans": _hits(bans),
        "hard_ban_count": sum(h.count for h in bans),
        "markers": _hits(soft),
        "marker_count": sum(h.count for h in soft),
        "rhythm": rep.rhythm.as_dict(),
        "morph": rep.morph.as_dict(),
        "structure": rep.structure.as_dict(),
    }


def _report(d: dict) -> str:
    lines = [f"ЧИСТОТА: {d['score']}/100  [{d['band']}]  ({d['words']} слов, жанр {d['genre']})",
             "  (≥85 чисто · 60-84 точечная правка · <60 рерайт)"]
    for p in d["penalties"]:
        lines.append(f"  {p['points']:+d}  {p['reason']}")
    if not d["penalties"]:
        lines.append("  без штрафов")
    for n in d["notes"]:
        lines.append(f"  ℹ  {n}")
    lines.append("")
    lines.append("HARD BANS:")
    if d["hard_bans"]:
        for h in d["hard_bans"]:
            lines.append(f"  ⛔ {h['name']} ×{h['count']}")
    else:
        lines.append("  ✓ чисто")
    lines.append("")
    lines.append(f"Маркеры: {d['marker_count']}")
    for h in sorted(d["markers"], key=lambda x: -x["count"])[:12]:
        lines.append(f"  • [{h['category']}] «{h['name']}» ×{h['count']}")
    return "\n".join(lines)


def compare(before: str, after: str, genre: str | None = None) -> dict:
    b, a = scan(before, genre), scan(after, genre)
    fd = diff_facts(before, after)
    return {
        "before": {"score": b["score"], "band": b["band"], "hard_ban_count": b["hard_ban_count"],
                   "marker_count": b["marker_count"]},
        "after": a,
        "delta": a["score"] - b["score"],
        "facts": fd.as_dict(),
        "facts_verdict": facts_verdict(fd),
    }


def _compare_report(d: dict) -> str:
    b, a = d["before"], d["after"]
    delta = d["delta"]
    lines = [f"ЧИСТОТА: было {b['score']}, стало {a['score']}/100  [{a['band']}]  ({delta:+d})",
             f"  запретов: {b['hard_ban_count']} → {a['hard_ban_count']}, "
             f"маркеров: {b['marker_count']} → {a['marker_count']}",
             "", "Факт-замок:", f"  {d['facts_verdict']}"]
    f = d["facts"]
    lines += [f"  ✗ новое: {x}" for x in f["added"]]
    lines += [f"  ⚠ потеряно: {x}" for x in f["lost"]]
    lines += [f"  ⚠ утверждение появилось: {x}" for x in f["claims_added"]]
    if f["soft_added"]:
        lines.append(f"  ℹ мелкие количества появились: {', '.join(f['soft_added'])}")
    return "\n".join(lines)


def call_tool(name: str, args: dict) -> dict:
    if name == "scan_text":
        text = args.get("text")
        if not isinstance(text, str):
            raise ValueError("нужен строковый аргумент text")
        if not text.strip():
            return {"content": [{"type": "text", "text": "Текст пуст, сканировать нечего."}],
                    "structuredContent": {"empty": True}, "isError": False}
        d = scan(text, args.get("genre"))
        return {"content": [{"type": "text", "text": _report(d)}],
                "structuredContent": d, "isError": False}
    if name == "compare_texts":
        before, after = args.get("before"), args.get("after")
        if not isinstance(before, str) or not isinstance(after, str):
            raise ValueError("нужны строковые аргументы before и after")
        d = compare(before, after, args.get("genre"))
        return {"content": [{"type": "text", "text": _compare_report(d)}],
                "structuredContent": d, "isError": False}
    raise KeyError(name)


def handle(req: dict) -> dict | None:
    """Ответ на один запрос; None для уведомлений (без id)."""
    method = req.get("method", "")
    rid = req.get("id")
    params = req.get("params") or {}
    is_notification = "id" not in req

    def ok(result):
        return None if is_notification else {"jsonrpc": "2.0", "id": rid, "result": result}

    def err(code, message):
        return None if is_notification else {"jsonrpc": "2.0", "id": rid,
                                             "error": {"code": code, "message": message}}

    if method == "initialize":
        return ok({
            "protocolVersion": params.get("protocolVersion") or PROTOCOL_VERSION,
            "capabilities": {"tools": {"listChanged": False}},
            "serverInfo": {"name": SERVER_NAME, "version": _version()},
            "instructions": ("Сканер следов нейросети для русского текста. scan_text даёт балл "
                             "и список того, что править; compare_texts сверяет правку с "
                             "исходником по баллу и фактам. Балл не вердикт об авторстве."),
        })
    if method == "ping":
        return ok({})
    if method == "tools/list":
        return ok({"tools": TOOLS})
    if method == "tools/call":
        name = params.get("name", "")
        try:
            return ok(call_tool(name, params.get("arguments") or {}))
        except KeyError:
            return err(-32602, f"неизвестный инструмент: {name}")
        except ValueError as exc:
            return ok({"content": [{"type": "text", "text": f"Ошибка: {exc}"}], "isError": True})
    if method.startswith("notifications/"):
        return None
    return err(-32601, f"метод не поддерживается: {method}")


def main() -> int:
    stdin = sys.stdin.buffer
    out = sys.stdout.buffer
    for raw in stdin:
        line = raw.decode("utf-8", errors="replace").strip()
        if not line:
            continue
        try:
            req = json.loads(line)
        except json.JSONDecodeError:
            resp = {"jsonrpc": "2.0", "id": None,
                    "error": {"code": -32700, "message": "невалидный JSON"}}
        else:
            try:
                resp = handle(req) if isinstance(req, dict) else {
                    "jsonrpc": "2.0", "id": None,
                    "error": {"code": -32600, "message": "ожидался объект запроса"}}
            except Exception as exc:  # noqa: BLE001 (сервер не должен падать на одном запросе)
                print(f"[humanizer-ru mcp] {exc!r}", file=sys.stderr)
                resp = {"jsonrpc": "2.0", "id": req.get("id"),
                        "error": {"code": -32603, "message": str(exc)}}
        if resp is not None:
            out.write((json.dumps(resp, ensure_ascii=False) + "\n").encode("utf-8"))
            out.flush()
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

"""Морфология: соотношение существительных к глаголам через pymorphy3.

Закрывает пункт чеклиста «соотношение существительных к глаголам ≤ 2.5:1» —
тот, который LLM не умеет считать на глаз. У AI-русского ~3:1, у людей ~2:1
(SKILL.md, паттерн #14, Biber framework). Чем выше отношение, тем «номинальнее»
текст, тем сильнее канцелярит.
"""

from __future__ import annotations

import functools
from dataclasses import dataclass

import pymorphy3
from razdel import tokenize


@functools.lru_cache(maxsize=1)
def _morph() -> "pymorphy3.MorphAnalyzer":
    return pymorphy3.MorphAnalyzer()


@dataclass
class MorphStats:
    nouns: int
    verbs: int           # глаголы + инфинитивы + деепричастия + причастия как глагольные формы
    noun_verb_ratio: float
    nominalizations: int  # отглагольные существительные (потенциальный канцелярит)
    tokens: int

    def as_dict(self) -> dict:
        return self.__dict__.copy()


# Что считаем «глагольным» — pymorphy3 теги (OpenCorpora):
_VERBAL = {"VERB", "INFN", "GRND", "PRTF", "PRTS"}
_NOUN = {"NOUN"}
_NOMINAL_SUFFIXES = ("ение", "ание", "ания", "ения", "ация", "изация", "ировка", "ость", "остей")


def _is_cyrillic_word(tok: str) -> bool:
    return any("а" <= c.lower() <= "я" or c.lower() == "ё" for c in tok)


def morph_stats(text: str) -> MorphStats:
    m = _morph()
    nouns = verbs = nominal = total = 0
    for t in tokenize(text):
        w = t.text
        if not _is_cyrillic_word(w):
            continue
        total += 1
        p = m.parse(w)[0]
        pos = p.tag.POS
        if pos in _NOUN:
            nouns += 1
            lemma = p.normal_form
            if lemma.endswith(_NOMINAL_SUFFIXES):
                nominal += 1
        elif pos in _VERBAL:
            verbs += 1
    ratio = (nouns / verbs) if verbs else float(nouns)
    return MorphStats(
        nouns=nouns,
        verbs=verbs,
        noun_verb_ratio=round(ratio, 2),
        nominalizations=nominal,
        tokens=total,
    )


NV_TARGET = 2.5  # из чеклиста SKILL.md


def morph_verdict(s: MorphStats) -> str:
    if s.noun_verb_ratio <= NV_TARGET:
        return f"✓ сущ./глаг. = {s.noun_verb_ratio} (цель ≤{NV_TARGET})"
    return f"⚠ сущ./глаг. = {s.noun_verb_ratio} (цель ≤{NV_TARGET}, канцелярит); номинализаций: {s.nominalizations}"

"""Score чистоты: сворачивает детерминированные сигналы в одно число 0-100.

Выше = текст читается живее/человечнее. Это НЕ детектор и НЕ вероятность ИИ:
просто агрегат уже считаемых метрик (хард-баны, маркеры, ритм, морфология),
поданный как обратная связь «было/стало». Опирается на пороги, которые уже
откалиброваны в burstiness/morphology и задокументированы в eval/RESULTS.md.

Пороги штрафов подобраны на eval/corpus (human → высокий score, raw-AI →
низкий, humanized → между). Калибровочный прогон: см. eval/run_eval.py.
"""

from __future__ import annotations

from dataclasses import dataclass, field

from .burstiness import CV_HUMAN_TARGET, STACCATO_MIN_RUN
from .markers import (GENRE_MUTED_BANS, GENRE_MUTED_CATEGORIES,
                      effective_hard_bans, mute_by_genre)
from .morphology import NV_TARGET
from .structure import (
    LISTICLE_MIN_ITEMS,
    LISTICLE_SHARE_AI,
    PARA_CV_AI,
    PARA_MIN_COUNT,
)

# Тире — отдельный случай: оно и хард-бан, и штатная русская пунктуация
# (Википедия, диапазоны, «это —»). Поэтому в score не рубим потолком, а
# штрафуем по плотности с допуском. Имя берём из HARD_BANS markers.py.
EM_DASH_NAME = "Длинное тире"
COPY_PASTE_CATEGORY = "Артефакты копипасты"

# Полосы. Совпадают с порогами вмешательства из SKILL.md.
BAND_CLEAN = 85   # ≥ — следы ИИ не мешают, не править
BAND_EDIT = 60    # ≥ — точечная правка; < — полный рерайт

# Доля ЛЮДЕЙ, у которых текст такой длины совсем без банов и без маркеров.
# Измерено на 14 973 человеческих текстах (Пикабу, M4, AINL), см. eval/.
#
# Зачем это здесь. Score мерит расстояние до нуля, а не до человека, и молча
# внушает, что цель это сто из ста. Человек нулём почти не бывает: на тексте в
# три сотни слов идеально чистых людей 15%, а не 100%. То есть высшая оценка
# означает попадание в редкий хвост распределения. Один такой текст неотличим;
# корпус из тысячи таких текстов отличим тривиально, потому что у людей хвост
# есть, а у вычищенного корпуса его нет.
#
# Штрафовать за чистоту мы не будем: это сломало бы сравнение «было и стало».
# Вместо этого при нулевом счёте отдаём заметку, чтобы цель читалась как
# «попади в типичную частоту», а не как «вычисти всё».
HUMAN_ZERO_SHARE: tuple[tuple[int, float], ...] = ((100, 42.2), (200, 21.0), (400, 15.1))
STERILE_MIN_WORDS = 100

# Рваная медитативность (каталог #49): цепочка обрывков «Короткие. Точные.
# Отдельные.» это почерк хуманайзера, который вывернул ровный ритм наизнанку:
# обратная сторона штрафа за ровный ритм. Штраф мягкий, как
# у номинальности: на 400 постах Пикабу правило срабатывает на 4, и половина из
# них настоящие авторские обрывки.
STACCATO_PENALTY = 8
STACCATO_PENALTY_MAX = 14


@dataclass
class ScoreResult:
    score: int                       # 0-100, выше = чище
    band: str                        # "чисто" | "правка" | "рерайт"
    penalties: list[tuple[str, int]]  # (причина, -очки) — это и есть verbose-отчёт
    notes: list[str] = field(default_factory=list)  # замечания без штрафа

    def as_dict(self) -> dict:
        return {
            "score": self.score,
            "band": self.band,
            "penalties": [{"reason": r, "points": p} for r, p in self.penalties],
            "notes": list(self.notes),
        }


def _band(score: float) -> str:
    if score >= BAND_CLEAN:
        return "чисто"
    if score >= BAND_EDIT:
        return "правка"
    return "рерайт"


def _plural(n: int, one: str, few: str, many: str) -> str:
    if n % 10 == 1 and n % 100 != 11:
        return one
    if 2 <= n % 10 <= 4 and not 12 <= n % 100 <= 14:
        return few
    return many


def _per100(count: int, words: int) -> float:
    return (count / words * 100) if words else 0.0


def cleanliness_score(report, genre: str | None = None) -> ScoreResult:
    """Считает score 0-100 из готового Report (см. humanizer_metrics.analyze).

    genre снимает штрафы за маркеры, законные для регистра (научный,
    юридический, художественный). Без genre режим строгий, как раньше.
    """
    words = report.rhythm.words or 1
    markers = mute_by_genre(report.markers, genre, GENRE_MUTED_CATEGORIES)
    dash_muted = EM_DASH_NAME in GENRE_MUTED_BANS.get(genre or "", set())
    penalties: list[tuple[str, int]] = []
    notes: list[str] = []
    score = 100.0

    # 1. Фразовые хард-баны (кроме тире). Однозначные AI-обороты: дорого.
    #    Частотные баны («Является») штрафуются только выше порога плотности.
    eff_bans = mute_by_genre(
        effective_hard_bans(report.hard_bans, report.rhythm.words),
        genre, GENRE_MUTED_BANS)
    hard_phrase = sum(h.count for h in eff_bans if h.marker != EM_DASH_NAME)
    if hard_phrase:
        pen = min(45, 12 * hard_phrase)
        score -= pen
        penalties.append((f"хард-баны (фразы): {hard_phrase}", -pen))

    # 2. Артефакты копипасты из чат-бота: текст буквально вставлен из ответа ИИ.
    copy_paste = sum(h.count for h in markers if h.category == COPY_PASTE_CATEGORY)
    if copy_paste:
        pen = 60
        score -= pen
        penalties.append((f"артефакты копипасты: {copy_paste}", -pen))

    # 3. Мягкие маркеры (кроме копипасты) по плотности на 100 слов.
    soft = sum(h.count for h in markers if h.category != COPY_PASTE_CATEGORY)
    if soft:
        pen = min(30, round(2 * _per100(soft, words)))
        if pen:
            score -= pen
            penalties.append((f"маркеры: {soft} ({_per100(soft, words):.1f}/100 слов)", -pen))

    # 4. Длинное тире по плотности с допуском ~2 на 100 слов: «—» штатно
    #    используется в русском (Википедия, «это —», диапазоны). Штраф мягкий,
    #    потому что на изданной прозе оно частая норма; сам бан держится на
    #    парном замере (markers.py, комментарий про парный замер).
    dash_density = 0.0 if dash_muted else _per100(report.rhythm.em_dash, words)
    if dash_density > 2.0:
        pen = min(8, round(3 * (dash_density - 2.0)))
        if pen:
            score -= pen
            penalties.append((f"тире: {report.rhythm.em_dash} ({dash_density:.1f}/100 слов)", -pen))

    # 5. Ровный ритм: чем ниже CV относительно цели 0.45, тем больше штраф.
    cv = report.rhythm.cv_len
    if report.rhythm.sentences >= 4 and cv < CV_HUMAN_TARGET:
        pen = min(20, round((CV_HUMAN_TARGET - cv) / CV_HUMAN_TARGET * 30))
        if pen:
            score -= pen
            penalties.append((f"ровный ритм (CV={cv}, цель ≥{CV_HUMAN_TARGET})", -pen))

    # 5б. Рваная медитативность: цепочки обрывков подряд. Обратная сторона
    #     ровного ритма, поэтому стоит рядом с ним.
    runs = report.rhythm.staccato_runs
    if runs:
        pen = min(STACCATO_PENALTY_MAX, STACCATO_PENALTY * runs)
        score -= pen
        penalties.append((
            f"рваная медитативность: {runs} {_plural(runs, 'цепочка', 'цепочки', 'цепочек')} "
            f"обрывков по {STACCATO_MIN_RUN}+ подряд (самая длинная {report.rhythm.staccato_max})", -pen))

    # 6. Номинальность: сущ./глаг. выше цели 2.5 = канцелярит. Слабый сигнал и
    #    главный источник ложных срабатываний (энциклопедический/юр. регистр
    #    легитимно номинален), поэтому штраф мягкий и низко ограничен.
    nv = report.morph.noun_verb_ratio
    if nv > NV_TARGET:
        pen = min(8, round((nv - NV_TARGET) / 0.5 * 3))
        if pen:
            score -= pen
            penalties.append((f"номинальность (сущ./глаг.={nv}, цель ≤{NV_TARGET})", -pen))

    # 7. Document-level: ровные по длине абзацы (burstiness абзацев). Срабатывает
    #    только на достаточно многоабзацном тексте, иначе инертно (короткая проза).
    st = report.structure
    if st.paragraphs >= PARA_MIN_COUNT and st.para_cv < PARA_CV_AI:
        pen = min(10, round((PARA_CV_AI - st.para_cv) / PARA_CV_AI * 20))
        if pen:
            score -= pen
            penalties.append((f"ровные абзацы (CV={st.para_cv}, цель ≥{PARA_CV_AI})", -pen))

    # 8. Document-level: listicle-сигнатура (засилье однотипных пунктов). Инертно
    #    на прозе без списков, бьёт по шаблонным гайдам/постам.
    if st.list_items >= LISTICLE_MIN_ITEMS and st.listicle_share > LISTICLE_SHARE_AI:
        pen = min(12, round((st.listicle_share - LISTICLE_SHARE_AI) * 30))
        if pen:
            score -= pen
            penalties.append((f"листикл ({st.list_items} пунктов, {int(st.listicle_share*100)}% строк)", -pen))

    # Заметка о стерильности. Не штраф: цель показать, что ноль это не середина
    # человеческого распределения, а его редкий край.
    #
    # Условие ровно то, что измерялось: ноль банов и ноль маркеров. Ритм,
    # номинальность и структура сюда не входят, иначе текст с минусом за ровный
    # ритм терял бы заметку, хотя по лексике он как раз стерилен.
    if not (hard_phrase or copy_paste or soft) and words >= STERILE_MIN_WORDS:
        share = next((s for limit, s in HUMAN_ZERO_SHARE if words < limit),
                     HUMAN_ZERO_SHARE[-1][1])
        notes.append(
            f"стерильно: ни одного маркера. Так пишет {share:.0f}% людей на тексте "
            f"в {words} слов, остальные {100 - share:.0f}% что-нибудь да используют. "
            "Цель не ноль, а типичная для жанра частота: вычищать дальше незачем")

    final = max(0, min(100, round(score)))
    return ScoreResult(score=final, band=_band(final), penalties=penalties, notes=notes)

"""Структурные метрики уровня документа: burstiness абзацев и listicle-сигнатура.

Дополняет burstiness.py (там ритм ПРЕДЛОЖЕНИЙ) тем, что детекторы оценивают на
УРОВНЕ ДОКУМЕНТА: одинаковая длина абзацев и засилье однотипных списков выдают
шаблонную генерацию, даже когда каждое предложение по отдельности вычищено.

Эти сигналы целят в многосекционный/листикл-текст (посты, гайды). На прозе
одним блоком они инертны (мало абзацев, нет списков) и в score не вносят штраф,
поэтому не задевают калибровку основного корпуса.
"""

from __future__ import annotations

import re
import statistics
from dataclasses import dataclass

from razdel import sentenize

from .morphology import _morph

# Строка-пункт списка: маркер «- * •» или «1. / 1)» в начале строки.
_LIST_RE = re.compile(r"^\s*(?:[-*•]|\d+[.)])\s+\S")

# Заголовок: markdown-решётки либо короткая строка без конечной пунктуации,
# за которой идёт пустая строка или абзац.
_HEADING_RE = re.compile(r"^\s*(?:#{1,6}\s+)?(\S.{0,79})$")
_WORD_RE = re.compile(r"[А-Яа-яЁё][А-Яа-яЁё-]*")
# Имя собственное капитализируется законно: тег pymorphy3 или незнакомое
# словарю слово (Стэнфорд, Хогвартс). Считаем только заглавные у нарицательных.
_PROPER_TAGS = {"Name", "Surn", "Geox", "Orgn", "Patr"}
# Служебные слова в заголовках пишутся строчными и в английском Title Case,
# поэтому их регистр ничего не говорит.
_STOPWORDS = {"и", "в", "на", "с", "к", "по", "для", "из", "о", "об", "а", "но", "или", "у", "за"}


@dataclass
class StructureStats:
    paragraphs: int          # число непустых абзацев (разделитель — пустая строка)
    para_mean_sent: float    # средняя длина абзаца в предложениях
    para_cv: float           # коэффициент вариации длин абзацев (burstiness абзацев)
    list_items: int          # строк-пунктов списка
    listicle_share: float    # доля строк-пунктов среди непустых строк
    title_case_headings: int  # заголовки в английском Title Case (паттерн #56)
    truncated_ending: bool    # текст оборван на полуслове (паттерн #57)

    def as_dict(self) -> dict:
        return self.__dict__.copy()


def _is_common_noun_capitalized(word: str) -> bool:
    """Слово с заглавной, которое словарь знает как нарицательное: «Жизнь»,
    «Образование». Имена собственные и незнакомые словарю слова не в счёт."""
    if not word[:1].isupper():
        return False
    if word.lower() in _STOPWORDS:
        return False
    p = _morph().parse(word.lower())[0]
    if not p.is_known:
        return False
    return not (_PROPER_TAGS & set(p.tag.grammemes))


def count_title_case_headings(text: str) -> int:
    """Заголовки, где с заглавной стоит не только первое слово: «Ранняя Жизнь
    и Образование». В русском так не пишут, это калька с английского."""
    hits = 0
    lines = text.splitlines()
    for i, raw in enumerate(lines):
        s = raw.strip()
        if not s:
            continue
        is_md_heading = s.startswith("#")
        # Строка без конечной пунктуации, короткая, за ней пусто: тоже заголовок.
        looks_like_heading = (
            len(s) <= 80 and s[-1] not in ".!?:;,"
            and (i + 1 >= len(lines) or not lines[i + 1].strip())
            and not _LIST_RE.match(raw)
        )
        if not (is_md_heading or looks_like_heading):
            continue
        words = _WORD_RE.findall(s)
        if len(words) < 3:
            continue  # на двух словах отличить заголовок от имени нельзя
        if sum(1 for w in words[1:] if _is_common_noun_capitalized(w)) >= 2:
            hits += 1
    return hits


def is_truncated(text: str) -> bool:
    """Текст оборван на полуслове: модель упёрлась в лимит токенов, а человек
    скопировал как есть. Последняя содержательная строка прозы обязана
    заканчиваться знаком конца предложения."""
    lines = [ln.rstrip() for ln in text.splitlines() if ln.strip()]
    if not lines:
        return False
    last = lines[-1]
    if last.startswith("#") or _LIST_RE.match(last) or last.startswith(("|", ">", "```")):
        return False  # заголовок, пункт списка, таблица: пунктуация не нужна
    if len(_WORD_RE.findall(last)) < 4:
        return False  # подпись, дата, короткая пометка
    return last[-1] not in ".!?…:»)\"'*_"


def structure_stats(text: str) -> StructureStats:
    paras = [p.strip() for p in re.split(r"\n\s*\n", text) if p.strip()]
    sent_lens = [len(list(sentenize(p))) for p in paras]
    sent_lens = [n for n in sent_lens if n > 0]
    n = len(sent_lens)

    mean = statistics.mean(sent_lens) if sent_lens else 0.0
    stdev = statistics.pstdev(sent_lens) if n > 1 else 0.0
    cv = (stdev / mean) if mean else 0.0

    lines = [ln for ln in text.splitlines() if ln.strip()]
    list_items = sum(1 for ln in lines if _LIST_RE.match(ln))
    share = (list_items / len(lines)) if lines else 0.0

    return StructureStats(
        paragraphs=n,
        para_mean_sent=round(mean, 1),
        para_cv=round(cv, 3),
        list_items=list_items,
        listicle_share=round(share, 3),
        title_case_headings=count_title_case_headings(text),
        truncated_ending=is_truncated(text),
    )


# Пороги (эвристика, согласована с логикой burstiness.py для предложений).
# Срабатывают только на достаточно длинном/структурированном тексте, чтобы не
# штрафовать короткую прозу одним-двумя абзацами.
PARA_CV_AI = 0.35          # ниже = слишком ровные по длине абзацы
PARA_MIN_COUNT = 6         # по нескольким коротким абзацам cv ненадёжен (малая
                           # выборка), судим о ритме абзацев только на длинном тексте
LISTICLE_SHARE_AI = 0.30   # доля строк-пунктов выше — текст «листиклом»
LISTICLE_MIN_ITEMS = 6     # и не меньше стольких пунктов (порог шаблонности)


def structure_verdict(s: StructureStats) -> str:
    parts = []
    if s.paragraphs >= PARA_MIN_COUNT and s.para_cv < PARA_CV_AI:
        parts.append(f"⚠ ровные абзацы (CV={s.para_cv}, цель ≥{PARA_CV_AI})")
    else:
        parts.append(f"✓ абзацы: {s.paragraphs}, CV={s.para_cv}")
    if s.list_items >= LISTICLE_MIN_ITEMS and s.listicle_share > LISTICLE_SHARE_AI:
        parts.append(f"⚠ листикл ({s.list_items} пунктов, {int(s.listicle_share*100)}% строк)")
    elif s.list_items:
        parts.append(f"пунктов списка: {s.list_items}")
    if s.title_case_headings:
        parts.append(f"⚠ Title Case в заголовках: {s.title_case_headings} (#56)")
    if s.truncated_ending:
        parts.append("⚠ обрыв на полуслове (#57)")
    return "; ".join(parts)

"""humanizer_metrics — детерминированные метрики живости текста.

Это грепабельная половина режима «Аудит» из SKILL.md: то, что считается
машиной, а не LLM. Используется и как локальный буст для Claude Code, и как
движок eval-харнеса (eval/run_eval.py), и как self-test самого скилла
(scripts/lint_skill.py).

Семантику (кальки, ирония, translationese, голос) тут не ловим — для этого
нужен сам скилл. Скрипты не работают в claude.ai web; скилл от них не зависит.
"""

from __future__ import annotations

from dataclasses import dataclass, replace

from .burstiness import RhythmStats, rhythm, rhythm_verdict
from .markers import (
    MarkerHit,
    marker_verdict,
    scan_hard_bans,
    scan_markers,
)
from .morphology import MorphStats, morph_stats, morph_verdict
from .structure import StructureStats, structure_stats, structure_verdict
from .score import ScoreResult, cleanliness_score

__all__ = [
    "Report",
    "analyze",
    "RhythmStats",
    "MorphStats",
    "StructureStats",
    "MarkerHit",
    "ScoreResult",
    "cleanliness_score",
    "rhythm",
    "morph_stats",
    "structure_stats",
    "scan_hard_bans",
    "scan_markers",
    "mask_foreign",
    "strip_foreign",
    "GAP",
    "QUOTE_MAX_WORDS",
]


@dataclass
class Report:
    hard_bans: list[MarkerHit]
    markers: list[MarkerHit]
    rhythm: RhythmStats
    morph: MorphStats
    structure: StructureStats

    @property
    def hard_ban_count(self) -> int:
        return sum(h.count for h in self.hard_bans)

    @property
    def marker_count(self) -> int:
        return sum(h.count for h in self.markers)

    def as_dict(self) -> dict:
        return {
            "hard_ban_count": self.hard_ban_count,
            "hard_bans": [(h.marker, h.count) for h in self.hard_bans],
            "marker_count": self.marker_count,
            "markers": [(h.category, h.marker, h.count) for h in self.markers],
            "rhythm": self.rhythm.as_dict(),
            "morph": self.morph.as_dict(),
            "structure": self.structure.as_dict(),
        }


# --- Код и цитаты не текст автора ------------------------------------------
# Разбор границ Markdown живёт в markdown.py (один построчный проход по
# CommonMark и таблица тестов), здесь только две проекции текста.
from .markdown import GAP, QUOTE_MAX_WORDS, mask_foreign, strip_foreign  # noqa: E402
from .facts import Facts, FactsDiff, diff_facts, extract_facts, facts_verdict  # noqa: E402

mask_code_and_quotes = mask_foreign
strip_code = strip_foreign


def analyze(text: str) -> Report:
    """Полный детерминированный прогон текста."""
    lexical = mask_code_and_quotes(text)
    prose = strip_code(text)
    stats = rhythm(prose)
    # Тире внутри короткой цитаты («Война — и мир») не типографика автора:
    # считаем его по заглушенному тексту, ритм по прозе с цитатами.
    stats = replace(stats, em_dash=lexical.count("—"))
    return Report(
        hard_bans=scan_hard_bans(lexical),
        markers=scan_markers(lexical),
        rhythm=stats,
        morph=morph_stats(prose),
        structure=structure_stats(prose),
    )