"""translate5 GUI Runner

このモジュールは、`translate5` ライブラリのGUIランナーアプリケーションを提供します。
ユーザーが設定を行い、翻訳処理 `execute()` を実行するためのTkinterベースのインターフェースです。

関連ドキュメント:
  :doc:`translate5_GUI_usage`

"""
import os
import threading
import configparser
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import traceback

try:
    from ttkthemes import ThemedTk
except Exception:
    ThemedTk = None

from translate5 import (
    initialize,
    update_variables,
    execute,
)
from tkai_lib_litellm import list_provider_models
from translate_core import CANONICAL_APIS, configure_translation_cfg, normalize_api

PROGRAM_NAME = "translate5 GUI Runner"

# 翻訳実行系と同じ、正規化済みprovider名だけを表示する。
API_CHOICES = list(CANONICAL_APIS)

DEFAULT_GEMINI_MODEL = "gemini-3.1-pro-preview"
DEFAULT_OPENAI_MODEL4 = "gpt-4o"
DEFAULT_OPENAI_MODEL5 = "gpt-5.4"



OPENAI_MODELS = ["gpt-5.4-pro", "gpt-5.3-chat-latest", "gpt-5-mini", "gpt-5-nano", "gpt-4o"]
GOOGLE_MODELS = ["gemini-3.1-pro-preview", "gemini-3-flash-preview", "gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.5-flash-light"]
DEEPL_MODELS = ["(auto)"]
LMSTUDIO_MODELS = ["qwen/qwen3.8-27b", "gpt-oss-20b"]

REASONING_EFFORTS = ["low", "medium", "xhigh"]
PROCESS_UNITS = ["paragraph", "run", "md"]  # md は GUI 専用で use_md フラグにマップ
MODES = [("日本語→英語 (je)", "je"), ("英語→日本語 (ej)", "ej")]

CONFIG_INI = os.path.splitext(os.path.abspath(__file__))[0] + ".ini"


class CopyableErrorDialog(tk.Toplevel):
    """エラーメッセージをコピー可能なテキスト領域で表示するダイアログ。

    tracebackなどの長いエラーメッセージをユーザーが選択・コピーできるようにします。
    """
    def __init__(self, parent, title, message):
        """ダイアログを初期化し、エラーメッセージを表示します。

        :param parent: 親ウィジェット。
        :type parent: tk.Widget
        :param title: ダイアログのタイトル。
        :type title: str
        :param message: 表示するエラーメッセージ。
        :type message: str
        """
        super().__init__(parent)
        self.title(title)
        self.geometry("700x400")

        self.transient(parent)
        self.grab_set()

        text_widget = tk.Text(self, wrap="word", font=("Courier", 10))
        text_widget.pack(padx=10, pady=10, fill="both", expand=True)
        text_widget.insert("1.0", message)
        text_widget.config(state="disabled")

        button = ttk.Button(self, text="Close", command=self.destroy)
        button.pack(pady=10)

        self.update_idletasks()
        x = parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
        y = parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
        self.geometry(f"+{x}+{y}")

        button.focus_set()
        self.wait_window(self)


class App:
    """`translate5` GUIアプリケーションのメインクラス。

    Tkinterウィジェットを構築し、ユーザー入力を処理し、`translate5` の翻訳ロジックを呼び出します。
    設定の読み込みと保存も担当します。
    """
    def __init__(self, master):
        """アプリケーションを初期化し、UIを構築します。

        `translate5` の設定を初期化し、各種ウィジェットを配置し、保存された設定を読み込みます。

        :param master: Tkinterのルートウィンドウ。
        :type master: tk.Tk or ttkthemes.ThemedTk
        """
        self.master = master
        master.title(PROGRAM_NAME)
        master.geometry("960x800")

        self.config = configparser.ConfigParser(comment_prefixes=('~',))

        print("--- [INFO] Initialize translate5 config ---")
        self.cfg, self.parser = initialize()
        self.cfg = update_variables(self.cfg, self.parser)
        print("endpoint (from env/args) =", getattr(self.cfg, "endpoint", None))

        self._translate_prompts = dict(getattr(self.cfg, "translate_prompts", {}))
        self._active_prompt_mode = getattr(self.cfg, "mode", "je")

        self._busy = False
        self._lmstudio_models = None

        self._build_ui()
        self._load_config()
        self._apply_mode_prompt(force=True)
        self._apply_api_to_models()

        master.protocol("WM_DELETE_WINDOW", self.on_close)

    # ---------------- UI 構築 ----------------
    def _build_ui(self):
        """アプリケーションのユーザーインターフェースを構築します。

        入力ファイル選択、モード設定、API/モデル選択、翻訳パラメータ、プロンプト入力などの
        各セクションのウィジェットを作成し、配置します。
        """
        # Input / Template
        io_frame = ttk.LabelFrame(self.master, text="Input / Template")
        io_frame.pack(fill="x", padx=10, pady=8)

        ttk.Label(io_frame, text="Input file (.docx/.pptx/.pdf/.html/.md/.rst/.txt):").grid(
            row=0, column=0, sticky="w", padx=6, pady=6
        )
        self.infile_var = tk.StringVar(
            value=self.cfg.infile if hasattr(self.cfg, "infile") else ""
        )
        e_in = ttk.Entry(io_frame, textvariable=self.infile_var)
        e_in.grid(row=0, column=1, sticky="ew", padx=6, pady=6)
        ttk.Button(io_frame, text="Browse", command=self._pick_infile).grid(
            row=0, column=2, padx=6, pady=6
        )

        ttk.Label(io_frame, text="HTML template (template_translate.html):").grid(
            row=1, column=0, sticky="w", padx=6, pady=6
        )
        self.tpl_var = tk.StringVar(
            value=getattr(self.cfg, "html_template_path", "template_translate.html")
        )
        e_tpl = ttk.Entry(io_frame, textvariable=self.tpl_var)
        e_tpl.grid(row=1, column=1, sticky="ew", padx=6, pady=6)
        ttk.Button(io_frame, text="Browse", command=self._pick_template).grid(
            row=1, column=2, padx=6, pady=6
        )

        io_frame.grid_columnconfigure(1, weight=1)

        # Mode / Options
        mode_frame = ttk.LabelFrame(self.master, text="Mode / Options")
        mode_frame.pack(fill="x", padx=10, pady=8)

        self.mode_var = tk.StringVar(value=getattr(self.cfg, "mode", "je"))
        col = 0
        for label, val in MODES:
            ttk.Radiobutton(
                mode_frame, text=label, variable=self.mode_var, value=val,
                command=self._on_mode_changed,
            ).grid(row=0, column=col, padx=6, pady=6, sticky="w")
            col += 1

        ttk.Label(mode_frame, text="Process unit:").grid(
            row=0, column=col, padx=12, pady=6, sticky="e"
        )
        self.proc_unit_var = tk.StringVar(
            value=getattr(self.cfg, "process_unit", "paragraph")
        )
        cb_proc = ttk.Combobox(
            mode_frame,
            state="readonly",
            values=PROCESS_UNITS,
            textvariable=self.proc_unit_var,
            width=10,
        )
        cb_proc.grid(row=0, column=col + 1, padx=6, pady=6, sticky="w")

        # API
        api_frame = ttk.LabelFrame(self.master, text="API")
        api_frame.pack(fill="x", padx=10, pady=8)

        ttk.Label(api_frame, text="API:").grid(
            row=0, column=0, padx=6, pady=6, sticky="w"
        )
        self.api_var = tk.StringVar(
            value=getattr(self.cfg, "requested_api", getattr(self.cfg, "api", "openai5"))
        )
        self.api_cb = ttk.Combobox(
            api_frame,
            state="readonly",
            values=API_CHOICES,
            textvariable=self.api_var,
            width=10,
        )
        self.api_cb.grid(row=0, column=1, padx=6, pady=6, sticky="w")
        self.api_cb.bind("<<ComboboxSelected>>", lambda e: self._apply_api_to_models())

        ttk.Label(api_frame, text="Model:").grid(
            row=0, column=2, padx=12, pady=6, sticky="e"
        )
        self.model_var = tk.StringVar(value="")
        self.model_cb = ttk.Combobox(
            api_frame,
            state="readonly",
            values=[],
            textvariable=self.model_var,
            width=24,
        )
        self.model_cb.grid(row=0, column=3, padx=6, pady=6, sticky="w")

        # Endpointは DeepL 用のみ。LM Studioの接続先は ai.env で設定する。
        ttk.Label(api_frame, text="Endpoint (DeepL):").grid(
            row=0, column=4, padx=12, pady=6, sticky="e"
        )
        endpoint_default = os.environ.get("endpoint", "")
        print("endpoint_default(env) =", endpoint_default)
        self.endpoint_var = tk.StringVar(
            value=endpoint_default if endpoint_default else ""
        )
        ttk.Entry(api_frame, textvariable=self.endpoint_var, width=50).grid(
            row=0, column=5, padx=6, pady=6, sticky="w"
        )

        api_frame.grid_columnconfigure(6, weight=1)

        # Generation Parameters
        gen_frame = ttk.LabelFrame(self.master, text="Generation Parameters")
        gen_frame.pack(fill="x", padx=10, pady=8)

        ttk.Label(gen_frame, text="temperature:").grid(
            row=0, column=0, padx=6, pady=6, sticky="e"
        )
        self.temp_var = tk.StringVar(
            value=str(getattr(self.cfg, "temperature", 0.3))
        )
        ttk.Entry(gen_frame, textvariable=self.temp_var, width=8).grid(
            row=0, column=1, padx=6, pady=6, sticky="w"
        )

        ttk.Label(gen_frame, text="max_tokens (or max_output_tokens):").grid(
            row=0, column=2, padx=12, pady=6, sticky="e"
        )
        self.max_tok_var = tk.StringVar(
            value=str(getattr(self.cfg, "max_tokens", 2000))
        )
        ttk.Entry(gen_frame, textvariable=self.max_tok_var, width=10).grid(
            row=0, column=3, padx=6, pady=6, sticky="w"
        )

        ttk.Label(gen_frame, text="reasoning_effort (LM Studio/Qwen):").grid(
            row=0, column=4, padx=12, pady=6, sticky="e"
        )
        self.effort_var = tk.StringVar(
            value=getattr(self.cfg, "reasoning_effort", "low")
        )
        ttk.Combobox(
            gen_frame,
            state="readonly",
            values=REASONING_EFFORTS,
            textvariable=self.effort_var,
            width=8,
        ).grid(row=0, column=5, padx=6, pady=6, sticky="w")

        # Translation Rules
        rule_frame = ttk.LabelFrame(self.master, text="Translation Rules")
        rule_frame.pack(fill="x", padx=10, pady=8)

        ttk.Label(rule_frame, text="min_translate_length:").grid(
            row=0, column=0, padx=6, pady=6, sticky="e"
        )
        self.min_len_var = tk.StringVar(
            value=str(getattr(self.cfg, "min_translate_length", 5))
        )
        ttk.Entry(rule_frame, textvariable=self.min_len_var, width=6).grid(
            row=0, column=1, padx=6, pady=6, sticky="w"
        )

        ttk.Label(rule_frame, text="allowed_translation_length_ratio:").grid(
            row=0, column=2, padx=12, pady=6, sticky="e"
        )
        self.len_ratio_var = tk.StringVar(
            value=str(getattr(self.cfg, "allowed_translation_length_ratio", 5.0))
        )
        ttk.Entry(rule_frame, textvariable=self.len_ratio_var, width=6).grid(
            row=0, column=3, padx=6, pady=6, sticky="w"
        )

        self.limit_mb_var = tk.BooleanVar(
            value=bool(
                getattr(
                    self.cfg,
                    "limit_to_multibyte_str",
                    self._mode_implies_mb(getattr(self.cfg, "mode", "je")),
                )
            )
        )
        ttk.Checkbutton(
            rule_frame,
            text="Limit to multibyte strings (JA source)",
            variable=self.limit_mb_var,
        ).grid(row=0, column=4, padx=12, pady=6, sticky="w")

        # Prompts（translate_prompt / reformat_prompt のみ）
        rp_frame = ttk.LabelFrame(self.master, text="Prompts")
        rp_frame.pack(fill="both", expand=True, padx=10, pady=8)

        ttk.Label(rp_frame, text="Translate Prompt (full instructions):").grid(
            row=0, column=0, padx=6, pady=6, sticky="nw"
        )
        self.tr_prompt = tk.Text(rp_frame, height=8, wrap="word")
        self.tr_prompt.grid(row=0, column=1, padx=6, pady=6, sticky="nsew")
        self.tr_prompt.insert(
            "1.0",
            getattr(self.cfg, "translate_prompt", ""),
        )

        ttk.Label(rp_frame, text="Reformat Prompt (PDF→MD etc.):").grid(
            row=1, column=0, padx=6, pady=6, sticky="nw"
        )
        self.rf_prompt = tk.Text(rp_frame, height=6, wrap="word")
        self.rf_prompt.grid(row=1, column=1, padx=6, pady=6, sticky="nsew")
        self.rf_prompt.insert(
            "1.0",
            getattr(self.cfg, "reformat_prompt", ""),
        )

        rp_frame.grid_columnconfigure(1, weight=1)
        rp_frame.grid_rowconfigure(0, weight=1)
        rp_frame.grid_rowconfigure(1, weight=1)

        # Buttons
        btn_frame = ttk.Frame(self.master)
        btn_frame.pack(pady=10)

        self.run_btn = ttk.Button(
            btn_frame, text="Run execute()", command=self._run_execute_thread
        )
        self.run_btn.grid(row=0, column=0, padx=6)

        ttk.Button(btn_frame, text="Close", command=self.on_close).grid(
            row=0, column=1, padx=6
        )

        # Status bar
        self.status = ttk.Label(
            self.master, text="Ready", relief="sunken", anchor="w"
        )
        self.status.pack(fill="x", padx=0, pady=(4, 0), ipady=2)

    def _mode_implies_mb(self, mode):
        """指定された翻訳モードがマルチバイト文字列（日本語ソース）を意味するかどうかを判定します。

        :param mode: 翻訳モード文字列（例: "je", "ej"）。
        :type mode: str
        :returns: モードが "j" で始まる場合にTrue。
        :rtype: bool
        """
        return True if mode and mode.startswith("j") else False

    def _remember_active_prompt(self):
        """現在アクティブな翻訳プロンプトの内容をメモリに保存します。

        翻訳モードが切り替わる際に、直前のプロンプト内容をモードごとに記憶しておくために使用されます。
        """
        if hasattr(self, "tr_prompt"):
            self._translate_prompts[self._active_prompt_mode] = self.tr_prompt.get(
                "1.0", "end"
            ).strip()

    def _apply_mode_prompt(self, force=False):
        """現在選択されている翻訳モードに対応するプロンプトをUIに適用します。

        必要に応じて、現在のプロンプトを保存し、新しいモードのプロンプトをテキストウィジェットに表示します。

        :param force: Trueの場合、現在のプロンプトを保存せずに強制的に適用します。
        :type force: bool
        """
        mode = self.mode_var.get()
        if not force:
            self._remember_active_prompt()
        prompt = self._translate_prompts.get(mode, "")
        if prompt:
            self.tr_prompt.delete("1.0", "end")
            self.tr_prompt.insert("1.0", prompt)
        self._active_prompt_mode = mode
        # 言語方向を切り替えたとき、対象文字種の既定値も合わせる。
        self.limit_mb_var.set(self._mode_implies_mb(mode))

    def _on_mode_changed(self):
        """翻訳モードが変更されたときに呼び出されるハンドラ。

        `_apply_mode_prompt` を呼び出してUIを更新します。
        """
        self._apply_mode_prompt()

    def _pick_infile(self):
        """入力ファイルを選択するためのファイルダイアログを開きます。

        選択されたファイルのパスを `infile_var` に設定します。
        """
        fp = filedialog.askopenfilename(
            title="Select input file",
            filetypes=[
                (
                    "Supported",
                    "*.docx;*.pptx;*.pdf;*.html;*.htm;*.md;*.rst;*.txt",
                ),
                ("All files", "*.*"),
            ],
        )
        if fp:
            self.infile_var.set(fp)

    def _pick_template(self):
        """HTMLテンプレートファイルを選択するためのファイルダイアログを開きます。

        選択されたファイルのパスを `tpl_var` に設定します。
        """
        fp = filedialog.askopenfilename(
            title="Select HTML template",
            filetypes=[("HTML", "*.html;*.htm"), ("All files", "*.*")],
        )
        if fp:
            self.tpl_var.set(fp)

    def _apply_api_to_models(self):
        """選択されたAPIに基づいて、モデル選択コンボボックスの候補を更新します。

        OpenAI, Gemini, LM Studio, DeepLなどのAPIに対応するモデルリストを設定し、
        現在のモデル選択を調整します。
        """
        api = normalize_api(self.api_var.get())
        if api != self.api_var.get():
            self.api_var.set(api)
        if api == "openai":
            self.model_cb["values"] = OPENAI_MODELS
            default = self.model_var.get() or getattr(self.cfg, "model", "gpt-5-mini")
            self.model_var.set(default if default in OPENAI_MODELS else "gpt-5-mini")
        elif api == "gemini":
            self.model_cb["values"] = GOOGLE_MODELS
            new_default = GOOGLE_MODELS[0] if GOOGLE_MODELS else ""
            default = self.model_var.get() or getattr(self.cfg, "model", new_default)
            self.model_var.set(
                default if default in GOOGLE_MODELS else new_default
            )
        elif api == "lmstudio":
            # モデル一覧はLM Studioサーバー側で管理する。ここは代表的な候補に加え、
            # ai.env の lmstudio_model を既定値として選ぶ。
            default = self.model_var.get() or getattr(self.cfg, "model", os.getenv("lmstudio_model", "qwen/qwen3.8-27b"))
            models = self._get_lmstudio_models()
            if default and default not in models:
                models.insert(0, default)
            self.model_cb["values"] = models
            self.model_var.set(default or LMSTUDIO_MODELS[0])
        elif api == "deepl":
            self.model_cb["values"] = DEEPL_MODELS
            self.model_var.set("(auto)")
        else:
            self.model_cb["values"] = []
            self.model_var.set("")

    def _get_lmstudio_models(self):
        """LM Studio APIから利用可能なモデル一覧を一度だけ取得します。

        モデルリストは一度だけ取得され、失敗した場合は既定の候補が使用されます。

        :returns: LM Studioで利用可能なモデル名のリスト。
        :rtype: list[str]
        """
        if self._lmstudio_models is not None:
            return list(self._lmstudio_models)

        try:
            models = list_provider_models("lmstudio")
            if models:
                self._lmstudio_models = models
                return list(models)
        except Exception as exc:
            print(f"[WARNING] LM Studio model list could not be loaded: {exc}")

        self._lmstudio_models = list(LMSTUDIO_MODELS)
        return list(self._lmstudio_models)

    def _worker_run(self):
        """`translate5` の `execute()` 関数を別スレッドで実行します。

        実行中のステータス更新、エラーハンドリング（コピー可能なエラーダイアログの表示を含む）、
        ボタン状態の更新を行います。
        """
        try:
            execute(self.cfg)
            self._set_status("Done.")
        except SystemExit:
            self._set_status("Finished (SystemExit).")
        except Exception as e:
            error_details = traceback.format_exc()
            self._set_status(f"Error: {e}")
            self._show_error_async("Execution Error", error_details)
        finally:
            self.master.after(
                0, lambda: self.run_btn.config(state="normal")
            )
            self._busy = False

    def _show_error_async(self, title, msg):
        """非同期にコピー可能なエラーダイアログを表示します。

        :param title: ダイアログのタイトル。
        :type title: str
        :param msg: 表示するエラーメッセージ。
        :type msg: str
        """
        self.master.after(
            0, lambda: CopyableErrorDialog(self.master, title, msg)
        )

    def _run_execute_thread(self):
        """`execute()` 関数をバックグラウンドスレッドで実行するための準備をします。

        UIからの設定を `cfg` オブジェクトに反映し、入力ファイルの存在チェックを行い、
        エラーがなければ `_worker_run` を別スレッドで開始します。
        """
        if self._busy:
            return
        try:
            self._update_cfg_from_ui()
        except Exception as e:
            messagebox.showerror(
                "設定エラー",
                f"設定の読み取りに失敗しました:\n{e}",
            )
            return
        if not os.path.isfile(self.cfg.infile):
            messagebox.showerror(
                "入力エラー",
                f"入力ファイルが見つかりません:\n{self.cfg.infile}",
            )
            return
        self._busy = True
        self.status.config(text="Running execute() ...")
        self.run_btn.config(state="disabled")
        t = threading.Thread(target=self._worker_run)
        t.daemon = True
        t.start()

    def _set_status(self, text):
        """ステータスバーのテキストを更新します。

        :param text: 表示するステータス文字列。
        :type text: str
        """
        self.master.after(0, lambda: self.status.config(text=text))

    def _update_cfg_from_ui(self):
        """UI上の現在の設定値を `self.cfg` オブジェクトに反映します。

        入力ファイル、テンプレート、モード、プロンプト、API、モデル、各種パラメータなど、
        すべてのGUI要素の値を `translate5` の設定オブジェクトに書き込みます。
        """
        # 基本情報
        self.cfg.infile = self.infile_var.get().strip()
        self.cfg.html_template_path = (
            self.tpl_var.get().strip() or "template_translate.html"
        )
        self.cfg.mode = self.mode_var.get()
        self._remember_active_prompt()

        # process_unit / use_md (md は GUI 独自指定として use_md=True にマップ)
        proc_unit = self.proc_unit_var.get()
        if proc_unit == "md":
            self.cfg.use_md = True
            # 実際の処理で使わないが一応 paragraph にしておく
            self.cfg.process_unit = "paragraph"
        else:
            self.cfg.use_md = False
            self.cfg.process_unit = proc_unit or "paragraph"

        # API / model: provider正規化・言語方向・API固有endpointの扱いは
        # translate_core.configure_translation_cfg() に集約する。
        api = self.api_var.get()
        model = self.model_var.get()

        # 各種パラメータ
        self.cfg.temperature = float(self.temp_var.get())
        self.cfg.max_tokens = int(float(self.max_tok_var.get()))
        self.cfg.reasoning_effort = self.effort_var.get()
        self.cfg.min_translate_length = int(float(self.min_len_var.get()))
        self.cfg.allowed_translation_length_ratio = float(
            self.len_ratio_var.get()
        )

        # translate5 新仕様: prompt は一体型のみ
        self.cfg.translate_prompt = (
            self._translate_prompts.get(self.cfg.mode, "")
            or getattr(self.cfg, "translate_prompt", "")
        )
        self.cfg.translate_prompts = dict(self._translate_prompts)
        self.cfg.reformat_prompt = (
            self.rf_prompt.get("1.0", "end").strip()
            or getattr(self.cfg, "reformat_prompt", "")
        )

        # APIキーなど（環境変数から）
        self.cfg.openai_api_key = os.getenv("OPENAI_API_KEY")
        self.cfg.google_api_key = os.getenv("GOOGLE_API_KEY")
        self.cfg.deepl_api_key = os.getenv("DEEPL_API_KEY")

        # その他固定値（translate5 と同等の既定値）
        self.cfg.output_html_path = None
        self.cfg.force_server_charcode = "utf-8"
        self.cfg.tsleep_rpm = getattr(self.cfg, "tsleep_rpm", 0.0)
        self.cfg.top_p = getattr(self.cfg, "top_p", 0.8)
        self.cfg.top_k = getattr(self.cfg, "top_k", 40)

        configure_translation_cfg(
            self.cfg,
            api=api,
            model=None if api == "deepl" else model,
            mode=self.cfg.mode,
            endpoint=self.endpoint_var.get().strip() or getattr(self.cfg, "endpoint", None),
            deepl_api_key=self.cfg.deepl_api_key,
            temperature=float(self.temp_var.get()),
            max_tokens=int(float(self.max_tok_var.get())),
            reasoning_effort=self.effort_var.get(),
            min_translate_length=int(float(self.min_len_var.get())),
            allowed_translation_length_ratio=float(self.len_ratio_var.get()),
            limit_to_multibyte_str=bool(self.limit_mb_var.get()),
            tsleep_rpm=self.cfg.tsleep_rpm,
        )

    def _load_config(self):
        """`CONFIG_INI` ファイルからアプリケーション設定を読み込み、UIに適用します。

        ウィンドウのジオメトリ、ファイルパス、モード、API、モデル、各種パラメータ、
        プロンプトなどを読み込み、UIウィジェットに設定します。
        """
        if os.path.exists(CONFIG_INI):
            try:
                self.config.read(CONFIG_INI, encoding="utf-8")
                s = self.config["Settings"]

                if "geometry" in s:
                    self.master.geometry(s.get("geometry"))

                self.infile_var.set(
                    s.get("infile", self.infile_var.get())
                )
                self.tpl_var.set(
                    s.get("html_template_path", self.tpl_var.get())
                )
                self.mode_var.set(
                    s.get("mode", self.mode_var.get())
                )
                self.proc_unit_var.set(
                    s.get("process_unit", self.proc_unit_var.get())
                )
                self.api_var.set(
                    s.get("api", self.api_var.get())
                )
                self.model_var.set(
                    s.get("model", self.model_var.get())
                )
                self.endpoint_var.set(
                    s.get("endpoint", self.endpoint_var.get())
                )
                self.temp_var.set(
                    s.get("temperature", self.temp_var.get())
                )
                self.max_tok_var.set(
                    s.get("max_tokens", self.max_tok_var.get())
                )
                self.effort_var.set(
                    s.get("reasoning_effort", self.effort_var.get())
                )
                self.min_len_var.set(
                    s.get(
                        "min_translate_length",
                        self.min_len_var.get(),
                    )
                )
                self.len_ratio_var.set(
                    s.get(
                        "allowed_translation_length_ratio",
                        self.len_ratio_var.get(),
                    )
                )
                self.limit_mb_var.set(
                    s.getboolean(
                        "limit_to_multibyte_str",
                        self.limit_mb_var.get(),
                    )
                )

                # 旧INIのtranslate_promptは、その時点で選択されている方向の
                # プロンプトとして読み込む。
                tr_p = s.get("translate_prompt", "").strip()
                if tr_p:
                    self._translate_prompts[self.mode_var.get()] = tr_p
                for mode in ("je", "ej"):
                    value = s.get(f"translate_prompt_{mode}", "").strip()
                    if value:
                        self._translate_prompts[mode] = value

                rf_p = s.get("reformat_prompt", "").strip()
                if rf_p:
                    self.rf_prompt.delete("1.0", "end")
                    self.rf_prompt.insert("1.0", rf_p)

            except Exception:
                # 壊れていても無視してデフォルトで続行
                pass

    def _save_config(self):
        """現在のアプリケーション設定を `CONFIG_INI` ファイルに保存します。

        UI上の現在の設定値を `ConfigParser` オブジェクトに書き込み、ファイルに保存します。
        """
        self._remember_active_prompt()
        if "Settings" not in self.config:
            self.config["Settings"] = {}
        s = self.config["Settings"]

        s["geometry"] = self.master.winfo_geometry()
        s["infile"] = self.infile_var.get()
        s["html_template_path"] = self.tpl_var.get()
        s["mode"] = self.mode_var.get()
        s["process_unit"] = self.proc_unit_var.get()
        s["api"] = self.api_var.get()
        s["model"] = self.model_var.get()
        s["endpoint"] = self.endpoint_var.get()
        s["temperature"] = self.temp_var.get()
        s["max_tokens"] = self.max_tok_var.get()
        s["reasoning_effort"] = self.effort_var.get()
        s["min_translate_length"] = self.min_len_var.get()
        s["allowed_translation_length_ratio"] = self.len_ratio_var.get()
        s["limit_to_multibyte_str"] = str(bool(self.limit_mb_var.get()))
        # translate_promptは旧版との互換用に現在の方向を保存する。
        s["translate_prompt"] = self._translate_prompts.get(self.mode_var.get(), "")
        s["translate_prompt_je"] = self._translate_prompts.get("je", "")
        s["translate_prompt_ej"] = self._translate_prompts.get("ej", "")
        s["reformat_prompt"] = self.rf_prompt.get("1.0", "end").strip()

        try:
            with open(CONFIG_INI, "w", encoding="utf-8") as f:
                self.config.write(f)
        except Exception as e:
            messagebox.showwarning(
                "保存警告",
                f"設定保存に失敗しました: {e}",
            )

    def on_close(self):
        """アプリケーション終了時に呼び出されるハンドラ。

        設定を保存し、メインウィンドウを閉じます。
        """
        try:
            self._save_config()
        finally:
            self.master.destroy()


def main():
    """アプリケーションのエントリポイント。

    Tkinterルートウィンドウを作成し、テーマを設定し、`App` クラスのインスタンスを生成して
    イベントループを開始します。
    """
    root = ThemedTk(theme="plastik") if ThemedTk else tk.Tk()
    if not ThemedTk:
        try:
            style = ttk.Style()
            style.theme_use("clam")
        except Exception:
            pass
    App(root)
    root.mainloop()


if __name__ == "__main__":
    main()