"""Format-aware translation backends for HTML, Markdown, and reStructuredText.

このモジュールは、HTML、Markdown、およびreStructuredTextドキュメントの形式を考慮した翻訳バックエンドを提供します。
構造化されたテキストコンテンツ（HTMLタグ、Markdown/RSTの書式、コードブロックなど）を保護しつつ、
表示可能なテキストや散文のみを翻訳します。これにより、翻訳後も元のドキュメントの構造と機能が維持されます。

:doc:`translate_backends_usage`
"""

import re

from bs4 import BeautifulSoup

from translate_core import check_translation, to_translate, translate


SKIP_HTML_TAGS = {"script", "style", "noscript", "template", "pre", "code", "kbd", "samp"}
PROTECTED_TOKEN = "@@TKPROTECTED_{:03d}@@"


def _translate_block(text, prompt, cfg, data, label="text"):
    """指定されたテキストブロックを翻訳し、翻訳結果を検証します。

    翻訳が必要な長さであるか、多バイト文字の制限を満たすかを確認し、翻訳エンジンを呼び出します。
    翻訳が失敗した場合や検証にパスしなかった場合は、元のテキストを返します。
    翻訳が成功し検証された場合、オリジナルと翻訳結果は ``data`` リストに追加されます。

    :param text: str: 翻訳するテキストブロック。
    :param prompt: str: 翻訳プロンプト。
    :param cfg: configparser.SectionProxy: 翻訳設定を含む設定オブジェクト。
    :param data: list[dict]: 翻訳のオリジナルと結果を ``{"original": ..., "translated": ...}`` 形式で格納するリスト。
    :param label: str, optional: ログ出力用のラベル。デフォルトは "text"。
    :returns: str: 翻訳された、または元のテキストブロック。
    """
    if not to_translate(text, cfg.min_translate_length, cfg.limit_to_multibyte_str):
        return text
    try:
        revised = translate(text, prompt, cfg)
    except Exception as exc:
        print(f"  *** Translation failed for {label}; keeping original: {exc}")
        return text
    if not check_translation(text, revised, cfg.allowed_translation_length_ratio):
        print(f"  *** Translation rejected for {label}; keeping original")
        return text
    data.append({"original": text, "translated": revised})
    return revised


def translate_html_document(html, prompt, cfg):
    """HTMLドキュメント内の表示可能なテキストを翻訳します。

    BeautifulSoupを使用してHTMLを解析し、スクリプト、スタイル、プリフォーマットされたコードなどの
    特定のタグ内のコンテンツを除く、すべてのテキストノードを走査します。
    各テキストノードは ``_translate_block`` を使用して翻訳されます。
    HTMLの構造は維持されます。

    :param html: str: 翻訳するHTML文字列。
    :param prompt: str: 翻訳プロンプト。
    :param cfg: configparser.SectionProxy: 翻訳設定を含む設定オブジェクト。
    :returns: tuple[str, list[dict]]: 翻訳されたHTML文字列と、オリジナルおよび翻訳済みテキストのペアのリスト。
    """
    soup = BeautifulSoup(html, "html.parser")
    data = []
    for node in soup.find_all(string=True):
        parent = node.parent
        if parent and parent.name and parent.name.lower() in SKIP_HTML_TAGS:
            continue
        original = str(node)
        revised = _translate_block(original, prompt, cfg, data, "HTML node")
        if revised != original:
            node.replace_with(revised)
    return str(soup), data


def _protect_inline(text, patterns):
    """テキスト内の特定のインライン要素を保護トークンに置き換えます。

    マークアップ言語のコードスニペット、リンク、参照などのインライン要素が
    翻訳エンジンによって変更されないように、一時的なプレースホルダー（保護トークン）に置き換えます。

    :param text: str: 処理するテキスト。
    :param patterns: list[str]: 保護するインライン要素に一致する正規表現パターンのリスト。
    :returns: tuple[str, list[tuple[str, str]]]: 保護トークンに置き換えられたテキストと、``(トークン, オリジナルテキスト)`` のペアのリスト。
    """
    protected = []

    def replace(match):
        token = PROTECTED_TOKEN.format(len(protected))
        protected.append((token, match.group(0)))
        return token

    for pattern in patterns:
        text = re.sub(pattern, replace, text)
    return text, protected


def _restore_inline(text, protected):
    """保護トークンを元のインライン要素に戻します。

    ``_protect_inline`` で置き換えられた保護トークンを、元のテキストコンテンツに復元します。
    すべてのトークンがテキスト内に存在しない場合（翻訳によって削除されたなど）はNoneを返します。

    :param text: str: 保護トークンを含むテキスト。
    :param protected: list[tuple[str, str]]: ``_protect_inline`` から返された ``(トークン, オリジナルテキスト)`` のペアのリスト。
    :returns: str or None: トークンがすべて復元されたテキスト。復元に失敗した場合はNone。
    """
    if any(token not in text for token, _ in protected):
        return None
    for token, original in protected:
        text = text.replace(token, original)
    return text


def _translate_markup_line(line, prompt, cfg, data, patterns, prefix_pattern=None):
    """マークアップ言語の1行を翻訳し、特定のインライン要素を保護します。

    行末の改行を保持し、行頭の書式（リストマーカーなど）やインライン要素
    （コードスニペット、リンクなど）を保護しつつ、行の本文を翻訳します。
    翻訳後、保護トークンを復元し、翻訳の整合性をチェックします。
    保護されたマークアップが変更された場合や翻訳が不適切な場合は、元の行が返されます。

    :param line: str: 翻訳するマークアップ行。
    :param prompt: str: 翻訳プロンプト。
    :param cfg: configparser.SectionProxy: 翻訳設定を含む設定オブジェクト。
    :param data: list[dict]: 翻訳のオリジナルと結果を ``{"original": ..., "translated": ...}`` 形式で格納するリスト。
    :param patterns: list[str]: 保護するインライン要素に一致する正規表現パターンのリスト。
    :param prefix_pattern: str, optional: 行頭の書式を抽出するための正規表現パターン。デフォルトはNone。
    :returns: str: 翻訳された、または元のマークアップ行。
    """
    ending = "\n" if line.endswith("\n") else ""
    body = line[:-1] if ending else line
    prefix = ""
    if prefix_pattern:
        match = re.match(prefix_pattern, body)
        if match:
            prefix, body = match.group(0), body[match.end():]
    masked, protected = _protect_inline(body, patterns)
    revised = _translate_block(masked, prompt, cfg, [], "markup line")
    if revised == masked:
        return line
    restored = _restore_inline(revised, protected)
    if restored is None or not check_translation(body, restored, cfg.allowed_translation_length_ratio):
        print("  *** Protected markup changed; keeping original line")
        return line
    data.append({"original": line.rstrip("\n"), "translated": (prefix + restored)})
    return prefix + restored + ending


MARKDOWN_INLINE = [
    r"`[^`]*`", r"!?\[[^\]]*\]\([^)]*\)", r"\{[A-Za-z][\w-]*\}",
    r"<https?://[^>]+>", r"https?://\S+",
]
RST_INLINE = [
    r":\w+(?::\w+)?:`[^`]*`", r"`[^`<>]+\s*<[^>]+>`_?", r"``[^`]*``", r"https?://\S+",
]


def translate_markdown_document(text, prompt, cfg):
    """Markdownドキュメント内のプロース（散文）を翻訳します。

    Markdownのフロントマター（---で囲まれた部分）、コードフェンス（```または~~~）、
    インデントされたコードブロック、およびHTMLコメントをスキップし、
    Markdownのインライン書式を保護しながらテキスト行を翻訳します。

    :param text: str: 翻訳するMarkdown文字列。
    :param prompt: str: 翻訳プロンプト。
    :param cfg: configparser.SectionProxy: 翻訳設定を含む設定オブジェクト。
    :returns: tuple[str, list[dict]]: 翻訳されたMarkdown文字列と、オリジナルおよび翻訳済みテキストのペアのリスト。
    """
    lines, data, in_fence = text.splitlines(keepends=True), [], False
    front_matter = bool(lines and lines[0].strip() == "---")
    for index, line in enumerate(lines):
        stripped = line.strip()
        if front_matter:
            if index and stripped in {"---", "..."}:
                front_matter = False
            continue
        if re.match(r"^\s*(```|~~~)", line):
            in_fence = not in_fence
            continue
        if (
            in_fence
            or re.match(r"^(\s{4}|\t)", line)
            or re.match(r"^\s*:\w[\w-]*:\s*", line)
            or stripped.startswith("<!--")
        ):
            continue
        lines[index] = _translate_markup_line(
            line, prompt, cfg, data, MARKDOWN_INLINE,
            r"^\s*(?:#{1,6}\s+|[-+*]\s+|\d+[.)]\s+|>\s*)",
        )
    return "".join(lines), data


def translate_rst_document(text, prompt, cfg):
    """reStructuredText (RST) ドキュメント内のプロース（散文）を翻訳します。

    Sphinxディレクティブ (例: ``.. note::``)、参照定義 (例: ``.. _label:``)、
    フィールドリスト、セクションタイトル区切り線、およびリテラルブロックを保護しつつ、
    RSTのインライン書式を考慮しながらテキスト行を翻訳します。

    :param text: str: 翻訳するreStructuredText文字列。
    :param prompt: str: 翻訳プロンプト。
    :param cfg: configparser.SectionProxy: 翻訳設定を含む設定オブジェクト。
    :returns: tuple[str, list[dict]]: 翻訳されたreStructuredText文字列と、オリジナルおよび翻訳済みテキストのペアのリスト。
    """
    lines, data = text.splitlines(keepends=True), []
    literal_indent = None
    for index, line in enumerate(lines):
        stripped = line.strip()
        indent = len(line) - len(line.lstrip(" "))
        if literal_indent is not None:
            if not stripped or indent >= literal_indent:
                continue
            literal_indent = None
        if re.match(r"^\s*\.\.\s+(?:\w|_)+::", line):  # ディレクティブ (例: .. note::)
            continue
        if re.match(r"^\s*\.\.\s+_[^:]+:", line) or re.match(r"^\s*:\w[^:]*:\s*", line):  # 参照定義、フィールドリスト
            continue
        if re.match(r"^\s*\.\.", line) or re.match(r"^[=\-~^\"`:#*+]+\s*$", line):  # コメント、セクション区切り線
            continue
        if stripped.endswith("::"):  # リテラルブロックの開始 (例: ::)
            lines[index] = _translate_markup_line(line, prompt, cfg, data, RST_INLINE)
            literal_indent = indent + 1
            continue
        lines[index] = _translate_markup_line(
            line, prompt, cfg, data, RST_INLINE, r"^\s*(?:[-*+]\s+|\d+[.)]\s+|\.\.\s+\w+::\s*)",
        )
    return "".join(lines), data