#!/usr/bin/env python3
"""Двуязычный глоссарий из параллельных изданий одной книги.

Задача: машинный перевод очередного тома цикла не должен расходиться с уже
изданными переводами в именах и реалиях. Частотный список даёт только имена;
пары вида White Council → Белый Совет так не получить.

Метод — выравнивание по относительной позиции в тексте. Абзацы английского и
русского изданий не совпадают ни числом, ни границами, но идут в одном порядке,
поэтому термин, встречающийся в английском тексте на 12%, 34% и 78% длины,
в переводе окажется примерно там же. Кандидат, чьи позиции совпали с позициями
термина лучше, чем с текстом вообще, и есть перевод.

Работает с fb2, epub и голым текстом. Только стандартная библиотека.
"""
import argparse
import collections
import difflib
import html
import re
import sys
import zipfile
from pathlib import Path

# Слова, с которых начинается предложение, — не имена собственные.
RU_STOP = {"Когда", "Если", "Что", "Как", "Это", "Она", "Они", "Мы", "Вы", "Так",
           "Потом", "Затем", "Даже", "Его", "Её", "Их", "Может", "Все", "Теперь",
           "Нет", "Да", "Меня", "Мне", "Тогда", "Только", "После", "Пока", "Там",
           "Здесь", "Однако", "Впрочем", "Просто", "Один", "Вот", "Или", "Почему",
           "Мой", "Моя", "Кто", "Конечно", "Хорошо", "Ага", "Думаю", "Возможно",
           "Глава", "Никто", "Ничего", "Что-то", "Кажется", "Значит", "Сейчас"}
EN_STOP = {"The", "A", "An", "And", "But", "I", "It", "He", "She", "They", "We",
           "You", "This", "That", "There", "Then", "When", "If", "So", "My", "His",
           "Her", "Chapter", "What", "Why", "How", "No", "Yes", "Not", "For", "Of",
           "In", "On", "At", "To", "With", "As", "Was", "Were", "Had", "Have",
           "Would", "Could", "Should", "One", "All", "Just", "Like", "Now", "Well",
           "Okay", "Oh", "Maybe", "Something", "Nothing", "Someone"}


def read_text(path):
    """Текст книги из fb2, epub или txt — разметка выкидывается."""
    p = Path(path)
    if p.suffix.lower() == ".epub":
        with zipfile.ZipFile(p) as z:
            parts = [z.read(n).decode("utf-8", "replace")
                     for n in z.namelist() if n.lower().endswith((".xhtml", ".html"))]
        raw = "\n".join(parts)
    elif p.suffix.lower() in (".fb2", ".xml"):
        raw = p.read_bytes().decode("utf-8", "replace")
    else:
        raw = p.read_text(encoding="utf-8", errors="replace")
    raw = re.sub(r"<(script|style|head)[^>]*>.*?</\1>", " ", raw, flags=re.S | re.I)
    raw = re.sub(r"</p>|</section>|<br\s*/?>", "\n", raw, flags=re.I)
    return html.unescape(re.sub(r"<[^>]+>", " ", raw))


def paragraphs(text):
    return [p.strip() for p in text.split("\n") if len(p.strip()) > 40]


def candidates(paras, pattern, stop, min_count):
    """{термин: [относительные позиции вхождений]}

    Позиция считается по символам, а не по номеру абзаца: русские издания
    разбивают диалоги построчно, и абзацев там втрое больше — по индексу
    тексты расходятся, по доле знаков идут почти вровень.
    """
    pos = collections.defaultdict(list)
    total = sum(len(p) for p in paras) or 1
    acc = 0
    for p in paras:
        rel = acc / total
        acc += len(p)
        for m in set(pattern.findall(p)):
            head = m.split()[0]
            if head in stop or len(m) < 3:
                continue
            pos[m].append(rel)
    return {t: v for t, v in pos.items() if len(v) >= min_count}


# Кириллица -> латиница для сравнения имён. Имена собственные в переводе почти
# всегда транслитерация, и это признак куда надёжнее позиционного совпадения.
LAT = {"а":"a","б":"b","в":"v","г":"g","д":"d","е":"e","ё":"e","ж":"j","з":"z",
       "и":"i","й":"i","к":"k","л":"l","м":"m","н":"n","о":"o","п":"p","р":"r",
       "с":"s","т":"t","у":"u","ф":"f","х":"h","ц":"c","ч":"c","ш":"s","щ":"s",
       "ъ":"","ы":"i","ь":"","э":"e","ю":"u","я":"a"}


def translit(s):
    return "".join(LAT.get(c, c) for c in s.lower())


def name_similarity(en, ru):
    """Похожесть после огрубления: латиница обеих сторон без удвоений и гласных
    на конце. Nicodemus/Никодимус дают почти единицу, Harry/Молли — ноль."""
    a = re.sub(r"[^a-z]", "", en.lower())
    b = re.sub(r"[^a-z]", "", translit(ru))
    a = re.sub(r"(.)\1+", r"\1", a)
    b = re.sub(r"(.)\1+", r"\1", b)
    if not a or not b:
        return 0.0
    return difflib.SequenceMatcher(None, a, b[:len(a) + 3]).ratio()


def overlap(a, b, tol):
    """Доля вхождений a, у которых нашлось вхождение b поблизости."""
    if not a or not b:
        return 0.0
    b = sorted(b)
    hit = 0
    for x in a:
        lo, hi = 0, len(b) - 1
        best = 1.0
        while lo <= hi:
            mid = (lo + hi) // 2
            best = min(best, abs(b[mid] - x))
            if b[mid] < x:
                lo = mid + 1
            else:
                hi = mid - 1
        if best <= tol:
            hit += 1
    return hit / len(a)


def main():
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("--en", action="append", required=True, help="английское издание")
    ap.add_argument("--ru", action="append", required=True, help="русское издание того же тома")
    ap.add_argument("--min-count", type=int, default=4)
    ap.add_argument("--tol", type=float, default=0.02, help="допуск по относительной позиции")
    ap.add_argument("--score", type=float, default=0.6, help="порог уверенности")
    ap.add_argument("--top", type=int, default=80)
    args = ap.parse_args()
    if len(args.en) != len(args.ru):
        sys.exit("нужно одинаковое число --en и --ru: это должны быть пары изданий")

    EN = re.compile(r"\b[A-Z][a-z]+(?:\s+(?:of\s+|the\s+)?[A-Z][a-z]+){0,2}")
    lower_seen = collections.Counter()
    ru_lower = collections.Counter()
    RU = re.compile(r"\b[А-ЯЁ][а-яё]+(?:\s+[А-ЯЁ][а-яё]+){0,2}")
    en_pos, ru_pos = collections.defaultdict(list), collections.defaultdict(list)
    for i, (fe, fr) in enumerate(zip(args.en, args.ru)):
        pe, pr = paragraphs(read_text(fe)), paragraphs(read_text(fr))
        # Настоящее имя собственное почти не встречается со строчной буквы:
        # так отсеиваются After, Once, More и прочие начала предложений.
        for w in re.findall(r"\b[a-z]{3,}\b", " ".join(pe)):
            lower_seen[w] += 1
        for w in re.findall(r"\b[а-яё]{3,}\b", " ".join(pr)):
            ru_lower[w] += 1
        print("пара %d: %d абзацев EN, %d RU" % (i + 1, len(pe), len(pr)), file=sys.stderr)
        for t, v in candidates(pe, EN, EN_STOP, 1).items():
            en_pos[t] += [(i, x) for x in v]
        for t, v in candidates(pr, RU, RU_STOP, 1).items():
            ru_pos[t] += [(i, x) for x in v]

    en_pos = {t: v for t, v in en_pos.items()
              if len(v) >= args.min_count
              and lower_seen[t.split()[0].lower()] < max(3, len(v) * 0.2)}
    # Зеркальный отсев: «Надеюсь», «Зачем», «Парень» — обычные слова, они
    # встречаются со строчной буквы и именами собственными быть не могут.
    ru_pos = {t: v for t, v in ru_pos.items()
              if len(v) >= args.min_count
              and ru_lower[t.split()[0].lower()] < max(3, len(v) * 0.2)}
    print("кандидатов: %d EN, %d RU" % (len(en_pos), len(ru_pos)), file=sys.stderr)

    by_book_ru = collections.defaultdict(dict)
    for t, v in ru_pos.items():
        for b, x in v:
            by_book_ru[b].setdefault(t, []).append(x)

    out = []
    for term, occ in sorted(en_pos.items(), key=lambda kv: -len(kv[1])):
        mine = collections.defaultdict(list)
        for b, x in occ:
            mine[b].append(x)
        best, best_score = None, 0.0
        for cand, cocc in ru_pos.items():
            # Частота кандидата должна быть сопоставима: «Гарри» встречается на
            # каждой странице и по одностороннему совпадению побеждает всех.
            if not (0.25 <= len(cocc) / len(occ) <= 4.0):
                continue
            fwd = back = tot_f = tot_b = 0.0
            for b, xs in mine.items():
                cand_pos = by_book_ru[b].get(cand)
                if not cand_pos:
                    continue
                fwd += overlap(xs, cand_pos, args.tol) * len(xs)
                back += overlap(cand_pos, xs, args.tol) * len(cand_pos)
                tot_f += len(xs); tot_b += len(cand_pos)
            if tot_f < len(occ) * 0.5 or not tot_b:
                continue
            # Симметричная мера: термин должен находить перевод, а перевод —
            # термин. Иначе частотное слово выигрывает у настоящего соответствия.
            score = (fwd / tot_f) * (back / tot_b)
            # Транслитерация — сильный самостоятельный довод: если написание
            # совпадает, позиционного подтверждения нужно куда меньше.
            sim = name_similarity(term, cand)
            if sim >= 0.72:
                score = max(score, sim) + 0.25
            elif sim < 0.3 and " " not in term:
                score *= 0.35   # разные имена, позиции совпали случайно
            if score > best_score:
                best, best_score = cand, score
        if best and best_score >= args.score:
            out.append((len(occ), best_score, term, best))

    print("# частота | уверенность | оригинал -> перевод")
    seen = set()
    for n, sc, en, ru in out[:args.top]:
        if (en, ru) in seen:
            continue
        seen.add((en, ru))
        print("%5d  %.2f  %-30s -> %s" % (n, sc, en, ru))


if __name__ == "__main__":
    main()