"""Small, dependency-light core shared by file and URL translation tools.

このモジュールは、ファイルやURLの翻訳ツールが共有する、軽量で依存関係の少ないコア機能を提供します。
主に、APIの正規化、言語ペアの決定、翻訳設定の構成、テキストの変換前処理、
そしてLiteLLMまたはDeepLを使用した実際の翻訳処理が含まれます。

関連リンク:
    :doc:`translate_core_usage`
"""

import re
import time

import requests

from tkai_lib_litellm import extract_text, query_ai, query_ai_compatible

API_ALIASES = {"openai5": "openai", "google": "gemini"}
CANONICAL_APIS = ("openai", "gemini", "lmstudio", "deepl")


def normalize_api(api):
    """翻訳ツールが使用する正規のプロバイダー名を返します。

    与えられたAPI名を、システムが認識する標準的なAPI名に変換します。
    エイリアスが定義されている場合はそれを使用し、最終的にサポートされているAPI名であることを確認します。

    :param api: str: 正規化するAPI名。
    :returns: str: 正規化されたAPI名。
    :raises ValueError: サポートされていない翻訳APIが指定された場合。
    """
    normalized = API_ALIASES.get((api or "").strip().lower(), (api or "").strip().lower())
    if normalized not in CANONICAL_APIS:
        raise ValueError(f"Unsupported translation API: {api}")
    return normalized


def language_pair_from_mode(mode):
    """確立された2文字のモード（je/ej/jj/ee）を言語コードに変換します。

    翻訳モード（例: 'je'は日本語から英語へ）を、ソース言語とターゲット言語の2文字のISOコード
    （'JA'または'EN'）のタプルに変換します。

    :param mode: str: 翻訳モードを示す2文字の文字列 (j=日本語, e=英語)。
    :returns: tuple[str, str]: ソース言語とターゲット言語のISOコード（例: ('JA', 'EN')）。
    :raises ValueError: 無効な翻訳モードが指定された場合。
    """
    mode = (mode or "je").lower()
    if len(mode) < 2 or mode[0] not in "je" or mode[1] not in "je":
        raise ValueError(f"Invalid translation mode: {mode}")
    return ("JA" if mode[0] == "j" else "EN", "JA" if mode[1] == "j" else "EN")


def configure_translation_cfg(
    cfg,
    *,
    api,
    model=None,
    mode=None,
    source_lang=None,
    target_lang=None,
    endpoint=None,
    deepl_api_key=None,
    temperature=None,
    max_tokens=None,
    reasoning_effort=None,
    min_translate_length=None,
    allowed_translation_length_ratio=None,
    limit_to_multibyte_str=None,
    tsleep_rpm=None,
):
    """`translate` 関数が消費するプロバイダーに依存しない設定を構成します。

    フロントエンドは独自のウィジェットやレガシーモデルフィールドを保持できますが、
    値が収集された後にこの関数を一度呼び出す必要があります。
    したがって、実際の翻訳パスは ``cfg.api`` と ``cfg.model`` にのみ依存します。
    この関数は、提供された引数に基づいて設定オブジェクトの属性を設定します。

    :param cfg: object: 設定を格納するオブジェクト。既存の属性も考慮されます。
    :param api: str: 使用する翻訳APIの名前（例: 'openai', 'deepl'）。
    :param model: str | None: 使用するAIモデルの名前。DeepLの場合は不要です。
    :param mode: str | None: 翻訳モード（例: 'je'）。指定された場合、source_langとtarget_langを上書きします。
    :param source_lang: str | None: ソース言語のISOコード（例: 'JA', 'EN'）。
    :param target_lang: str | None: ターゲット言語のISOコード（例: 'JA', 'EN'）。
    :param endpoint: str | None: DeepL APIのエンドポイントURL。
    :param deepl_api_key: str | None: DeepL APIの認証キー。
    :param temperature: float | None: AIモデルの応答のランダム性を制御する温度設定。
    :param max_tokens: int | None: AIモデルの応答で生成される最大トークン数。
    :param reasoning_effort: float | None: LM Studioなどのモデルにおける推論の労力。
    :param min_translate_length: int | None: 翻訳を試みる最小テキスト長。
    :param allowed_translation_length_ratio: float | None: 翻訳結果の許容される最大長と元のテキスト長の比率。
    :param limit_to_multibyte_str: bool | None: 翻訳を多バイト文字を含む文字列に限定するかどうか。
    :param tsleep_rpm: float | None: APIリクエスト間の遅延時間（RPMに基づく）。
    :returns: object: 設定が更新された ``cfg`` オブジェクト。
    """
    cfg.api = normalize_api(api)
    cfg.model = model or None
    if mode is not None:
        source_lang, target_lang = language_pair_from_mode(mode)
        cfg.mode = mode
    cfg.source_lang = (source_lang or getattr(cfg, "source_lang", "JA")).upper()
    cfg.target_lang = (target_lang or getattr(cfg, "target_lang", "EN")).upper()
    cfg.endpoint = endpoint if cfg.api == "deepl" else None
    if deepl_api_key is not None:
        cfg.deepl_api_key = deepl_api_key
    for name, value in {
        "temperature": temperature,
        "max_tokens": max_tokens,
        "reasoning_effort": reasoning_effort,
        "min_translate_length": min_translate_length,
        "allowed_translation_length_ratio": allowed_translation_length_ratio,
        "tsleep_rpm": tsleep_rpm,
    }.items():
        if value is not None:
            setattr(cfg, name, value)
    if limit_to_multibyte_str is None:
        limit_to_multibyte_str = cfg.source_lang == "JA"
    cfg.limit_to_multibyte_str = bool(limit_to_multibyte_str)
    return cfg


def process_template(template, context):
    """エスケープされた制御文字と ``{{ name }}`` プレースホルダーを展開します。

    テンプレート文字列内のエスケープシーケンス（\\t, \\n, \\r）を実際の制御文字に変換し、
    ``{{ key }}`` の形式で記述されたプレースホルダーを `context` 辞書の値で置換します。
    キーが `context` に存在しない場合は、プレースホルダーはそのまま残されます。

    :param template: str: 処理するテンプレート文字列。
    :param context: dict[str, Any]: プレースホルダーを置換するためのキーと値の辞書。
    :returns: str: 展開されたテンプレート文字列。
    """
    template = template.replace(r"\t", "\t").replace(r"\n", "\n").replace(r"\r", "\r")
    return re.sub(
        r"\{\{\s*(.*?)\s*\}\}",
        lambda match: str(context.get(match.group(1).strip(), match.group(0))),
        template,
    )


def check_multibyte_str(text, limit_to_multibyte_str):
    """文字列に多バイト文字が含まれているかを確認します。

    `limit_to_multibyte_str` がTrueの場合のみ、テキストに多バイト文字（U+0800からU+FFFFの範囲）が
    含まれているかをチェックします。Falseの場合は常にTrueを返します。

    :param text: str: チェックするテキスト。
    :param limit_to_multibyte_str: bool: 多バイト文字の有無でチェックを制限するかどうか。
    :returns: bool: テキストが多バイト文字を含んでいる（またはチェックが制限されていない）場合はTrue、それ以外はFalse。
    """
    return not limit_to_multibyte_str or bool(re.search(r"[\u0800-\uFFFF]", text))


def to_translate(text, min_translate_length=1, limit_to_multibyte_str=False):
    """指定されたテキストが翻訳対象であるかどうかを判断します。

    テキストがNoneでないこと、最小長を超えること、
    そして多バイト文字の制限がある場合はそれに適合すること、
    または英字が含まれることを確認します。

    :param text: str | None: 翻訳対象として確認するテキスト。
    :param min_translate_length: int: 翻訳を試みる最小テキスト長。デフォルトは1。
    :param limit_to_multibyte_str: bool: 翻訳を多バイト文字を含む文字列に限定するかどうか。デフォルトはFalse。
    :returns: bool: テキストが翻訳対象と見なされる場合はTrue、それ以外はFalse。
    """
    if text is None:
        return False
    text = str(text).strip()
    if len(text) < min_translate_length:
        return False
    has_multibyte = check_multibyte_str(text, limit_to_multibyte_str)
    if not has_multibyte and not re.search(r"[a-zA-Z]", text):
        return False
    return has_multibyte if limit_to_multibyte_str else True


def n_leading_chars(text, char="#"):
    """文字列の先頭にある特定の文字の数を数えます。

    :param text: str: チェックする文字列。
    :param char: str: 先頭から数える文字。デフォルトは'#'。
    :returns: int: 先頭にある指定された文字の数。
    """
    return len(text) - len(text.lstrip(char))


def check_translation(original, translated, allowed_translation_length_ratio=5.0):
    """翻訳結果の妥当性を基本的な基準に基づいてチェックします。

    翻訳されたテキストが空でないこと、マークダウンのブロックとして始まっていないこと、
    先行するハッシュ記号やアスタリスクの数が不適切でないこと、
    そして元のテキストに対する長さの比率が許容範囲内であることを確認します。

    :param original: str: 翻訳元のテキスト。
    :param translated: str: 翻訳されたテキスト。
    :param allowed_translation_length_ratio: float: 翻訳結果の許容される最大長と元のテキスト長の比率。デフォルトは5.0。
    :returns: bool: 翻訳結果が妥当と見なされる場合はTrue、それ以外はFalse。
    """
    if not translated or translated.startswith(("'''", "```")):
        return False
    before = n_leading_chars(original, "#")
    after = n_leading_chars(translated, "#")
    if after > before:
        return False
    before = n_leading_chars(original, "*")
    after = n_leading_chars(translated, "*")
    if after == before + 1:
        return False
    return not original or len(translated) <= len(original) * allowed_translation_length_ratio


def _translate_with_deepl(text, cfg):
    """DeepL APIを使用してテキストを翻訳します。

    DeepL APIキーとエンドポイントが設定されていることを確認し、
    指定されたテキストをDeepLに送信して翻訳結果を取得します。

    :param text: str: 翻訳するテキスト。
    :param cfg: object: 翻訳設定を含むオブジェクト（deepl_api_key, endpoint, source_lang, target_lang, timeout）。
    :returns: str: DeepLによって翻訳されたテキスト。
    :raises RuntimeError: DEEPL_API_KEYまたはDeepLエンドポイントが設定されていない場合。
    :raises requests.exceptions.RequestException: DeepL APIからのHTTPエラーが発生した場合。
    """
    if not getattr(cfg, "deepl_api_key", None):
        raise RuntimeError("DEEPL_API_KEY is not set")
    if not getattr(cfg, "endpoint", None):
        raise RuntimeError("DeepL endpoint is not set")
    response = requests.post(
        cfg.endpoint,
        headers={"Authorization": f"DeepL-Auth-Key {cfg.deepl_api_key}"},
        data={"text": text, "source_lang": cfg.source_lang, "target_lang": cfg.target_lang},
        timeout=getattr(cfg, "timeout", 60),
    )
    response.raise_for_status()
    return response.json()["translations"][0]["text"]


def translate(text, prompt, cfg):
    """LiteLLMまたはDeepLを介して1つのテキストブロックを翻訳/校正します。

    設定オブジェクト `cfg` の `api` に基づいて、DeepL APIまたはLiteLLM互換のAIモデルを使用して
    テキストを翻訳します。翻訳後、設定されたRPM (Requests Per Minute) に基づいて
    遅延を発生させることができます。

    :param text: str: 翻訳するテキストブロック。
    :param prompt: str: AIモデルに送信するプロンプトのテンプレート。`{{ text }}` などのプレースホルダーを含めます。
    :param cfg: object: 翻訳設定を含むオブジェクト。
                  (api, model, temperature, max_tokens, reasoning_effort, tsleep_rpm, deepl_api_key, endpoint, source_lang, target_lang)
    :returns: str: 翻訳または校正されたテキスト。
    :raises RuntimeError: DeepL APIキーまたはエンドポイントが設定されていない場合（DeepL使用時）、またはAI APIがテキストを返さない場合。
    """
    if cfg.api == "deepl":
        result = _translate_with_deepl(text, cfg)
    else:
        prompt_text = process_template(
            prompt,
            {"text": text, "additional_prompt": "翻訳・校正結果のみを出力してください。前置きや後付けのメッセージは不要です。"},
        )
        if cfg.api == "lmstudio":
            kwargs = {"temperature": cfg.temperature, "max_tokens": cfg.max_tokens}
            if getattr(cfg, "reasoning_effort", None):
                kwargs["extra_body"] = {"reasoning_effort": cfg.reasoning_effort}
            response = query_ai(prompt_text, cfg.model, role="", provider="lmstudio", **kwargs)
        else:
            response = query_ai_compatible(
                prompt_text, cfg.model, role="", provider=cfg.api,
                temperature=cfg.temperature, max_tokens=cfg.max_tokens,
                reasoning_effort=getattr(cfg, "reasoning_effort", None),
            )
        result = extract_text(response)
        if not result:
            raise RuntimeError("Translation API returned no text")

    delay = getattr(cfg, "tsleep_rpm", 0.0)
    if delay > 0:
        time.sleep(delay)
    return result.strip()
