full_anonymizer.py

"""
匿名化ツール (Full Anonymizer)

機能:
  - フォルダ D&D → フォルダ名/ファイル名/テキスト内容/DICOMタグ を一括匿名化
  - Feistel暗号化モード / 対応表作成モード
  - 全設定を SEED.conf に一元管理 (exe化対応)

暗号方式:
  Feistel cipher (PBKDF2-SHA256 鍵導出 + HMAC-SHA256 ラウンド関数, 16 rounds)
  ※ ID桁数=7, 接頭辞=K の場合、ID-Anonymizer.ps1 と完全互換

暗号化SEED値・設定:
  同じフォルダ内の SEED.conf に暗号化SEED値と設定が保存されます。
  SEED値を変更すると、全く異なる匿名化結果になります。
"""

import os
import sys
import json
import math
import hmac
import hashlib
import struct
import shutil
import re
import secrets
import string
import csv
import zipfile
import queue
import threading
import tkinter as tk
from tkinter import filedialog, messagebox
from pathlib import Path
from datetime import datetime
import xml.etree.ElementTree as ET

try:
    import customtkinter as ctk
except ImportError:
    print("customtkinter が必要です: pip install customtkinter")
    sys.exit(1)

try:
    import windnd
    HAS_WINDND = True
except ImportError:
    HAS_WINDND = False

try:
    import pydicom
    HAS_PYDICOM = True
except ImportError:
    HAS_PYDICOM = False

try:
    import openpyxl
    HAS_OPENPYXL = True
except ImportError:
    HAS_OPENPYXL = False


# ============================================================
# 暗号化SEED値 読み込み / 生成 / 保存
# ============================================================
# exe化対応: frozen時は exe の場所、通常時は .py の場所
if getattr(sys, 'frozen', False):
    _APP_DIR = Path(os.path.dirname(sys.executable))
else:
    _APP_DIR = Path(os.path.dirname(os.path.abspath(__file__)))
_SEED_FILE = _APP_DIR / "SEED.conf"
_PW_GEN_LENGTH = 20  # 自動生成SEED値の長さ (英大小+数字+記号 → ~131 bit)


def _load_password_file() -> tuple:
    """SEED.conf から暗号化SEED値・メモ・設定を読み込む。
    Returns: (password, memo, settings_dict)
    """
    if not _SEED_FILE.exists():
        return "", "", {}
    try:
        text = _SEED_FILE.read_text(encoding="utf-8")
    except Exception:
        return "", "", {}
    lines = text.split("\n")
    password = lines[0].strip() if lines else ""
    memo_parts = []
    settings = {}
    current_section = None
    for line in lines[1:]:
        stripped = line.strip()
        if stripped.startswith("# メモ:"):
            memo_parts.append(stripped[len("# メモ:"):].strip())
        elif stripped.startswith("[") and stripped.endswith("]"):
            current_section = stripped[1:-1]
            settings[current_section] = {}
        elif current_section and "=" in stripped and not stripped.startswith("#"):
            key, _, value = stripped.partition("=")
            settings[current_section][key.strip()] = value.strip()
    return password, "\n".join(memo_parts), settings


def _generate_password(length: int = _PW_GEN_LENGTH) -> str:
    """暗号学的に安全なランダムSEED値を生成"""
    alphabet = string.ascii_letters + string.digits + "!@#$%&*+-=?"
    while True:
        pw = "".join(secrets.choice(alphabet) for _ in range(length))
        # 全文字種が含まれることを保証
        if (re.search(r"[a-z]", pw) and re.search(r"[A-Z]", pw)
                and re.search(r"[0-9]", pw) and re.search(r"[^a-zA-Z0-9]", pw)):
            return pw


def _save_password_file(password: str, memo: str = "", settings: dict = None) -> Path:
    """SEED.conf に暗号化SEED値 + メタデータ + 全設定を保存"""
    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    lines = [password, ""]
    lines.append(f"# 作成日時: {ts}")
    if memo.strip():
        for line in memo.strip().splitlines():
            lines.append(f"# メモ: {line}")
    lines.append("")
    lines.append("# --- 1行目が暗号化SEED値です ---")
    lines.append("# SEED値を変更すると過去の匿名化結果とは異なる結果になります")
    lines.append("# このファイルは匿名化データと一緒に配布しないでください")
    if settings:
        for section, kvs in settings.items():
            lines.append("")
            lines.append(f"[{section}]")
            for k, v in kvs.items():
                lines.append(f"{k} = {v}")
    lines.append("")
    _SEED_FILE.write_text("\n".join(lines), encoding="utf-8")
    return _SEED_FILE


SEED, _LOADED_MEMO, _LOADED_SETTINGS = _load_password_file()


# SEED値強度の最低ライン (ビット)
# PBKDF2 100k回 × 高性能GPU 100万回/秒 × 100年 ≒ 2^71.5
# 余裕をもって 72 bit 以上を要求
MIN_ENTROPY_BITS = 72

# 攻撃想定: PBKDF2-100k を GPU 並列で毎秒 100 万回試行
ATTACK_RATE = 1_000_000


def _estimate_entropy(password: str) -> float:
    """使用文字種からエントロピー (bit) を推定"""
    if not password:
        return 0.0
    pool = 0
    if re.search(r"[a-z]", password):
        pool += 26
    if re.search(r"[A-Z]", password):
        pool += 26
    if re.search(r"[0-9]", password):
        pool += 10
    if re.search(r"[^a-zA-Z0-9]", password):
        pool += 33
    if pool == 0:
        pool = 1
    return len(password) * math.log2(pool)


def _crack_time_display(entropy: float) -> str:
    """推定解読時間を人間向け文字列で返す"""
    if entropy <= 0:
        return "即座"
    seconds = (2 ** entropy) / ATTACK_RATE
    years = seconds / (365.25 * 86400)
    if years < 1:
        return f"約 {seconds / 3600:.0f} 時間"
    if years < 1000:
        return f"約 {years:.0f} 年"
    exp = int(math.log10(years))
    return f"約 10^{exp} 年"


def _password_guidance() -> str:
    """必要文字数のガイダンス文字列を返す"""
    examples = []
    for label, pool in [("英小文字のみ", 26), ("英大小+数字", 62), ("英大小+数字+記号", 95)]:
        need = math.ceil(MIN_ENTROPY_BITS / math.log2(pool))
        examples.append(f"  {label}: {need}文字以上")
    return "\n".join(examples)
# ============================================================


# ============================================================
# Feistel cipher コア (ID-Anonymizer.ps1 と同一アルゴリズム)
# ============================================================

FEISTEL_ROUNDS = 16


def get_cipher_params(id_digits: int) -> tuple:
    """(half_mod, output_digits) を返す"""
    if id_digits <= 6:
        return 1000, 6    # block = 1,000,000 (5〜6桁をカバー)
    else:
        return 10000, 8   # block = 100,000,000 (7〜8桁をカバー)


def derive_key(seed: str) -> bytes:
    """PBKDF2-SHA256 でシードから 256bit キーを導出"""
    salt = b"ID-Anonymizer-SFRT-v1-Salt"
    return hashlib.pbkdf2_hmac(
        "sha256", seed.encode("utf-8"), salt, 100000, dklen=32
    )


def _feistel_f(half: int, round_num: int, key: bytes, half_mod: int) -> int:
    data = f"{round_num}|{half}".encode("utf-8")
    h = hmac.new(key, data, hashlib.sha256).digest()
    return struct.unpack_from("<I", h)[0] % half_mod


def protect_id(plain_id: str, key: bytes, id_digits: int = 7, prefix: str = "K") -> str:
    """N桁 ID → prefix+M桁 匿名化 ID"""
    half_mod, out_digits = get_cipher_params(id_digits)
    max_val = half_mod * half_mod - 1
    num = int(plain_id)
    if num < 0 or num > max_val:
        raise ValueError(f"ID は 0〜{max_val} の範囲")
    left, right = divmod(num, half_mod)
    for r in range(FEISTEL_ROUNDS):
        f = _feistel_f(right, r, key, half_mod)
        left, right = right, (left + f) % half_mod
    return f"{prefix}{left * half_mod + right:0{out_digits}d}"


def unprotect_id(cipher_id: str, key: bytes, id_digits: int = 7, prefix: str = "K") -> str:
    """prefix+M桁 匿名化 ID → N桁 ID"""
    half_mod, out_digits = get_cipher_params(id_digits)
    max_val = half_mod * half_mod - 1
    stripped = cipher_id.strip()
    if prefix and stripped.startswith(prefix):
        stripped = stripped[len(prefix):]
    elif prefix and stripped.lower().startswith(prefix.lower()):
        stripped = stripped[len(prefix):]
    num = int(stripped)
    if num < 0 or num > max_val:
        raise ValueError("不正な匿名化ID")
    left, right = divmod(num, half_mod)
    for r in range(FEISTEL_ROUNDS - 1, -1, -1):
        f = _feistel_f(left, r, key, half_mod)
        left, right = (right - f) % half_mod, left
    return f"{left * half_mod + right:0{id_digits}d}"


# ============================================================
# 定数
# ============================================================

DEFAULT_DICOM_TAGS = {
    "PatientName":            ("患者名",             "{id}"),
    "PatientID":              ("患者ID",             "{id}"),
    "PatientBirthDate":       ("生年月日",           ""),
    "PatientSex":             ("患者性別",           ""),
    "StudyDate":              ("検査日",             ""),
    "SeriesDate":             ("シリーズ日",         ""),
    "AcquisitionDate":        ("収集日",             ""),
    "ContentDate":            ("コンテンツ日",       ""),
    "AccessionNumber":        ("アクセッション番号", ""),
    "InstitutionName":        ("施設名",             ""),
    "Manufacturer":           ("製造元",             ""),
    "ReferringPhysicianName": ("紹介医",             ""),
    "OperatorsName":          ("操作者名",           ""),
    "StudyDescription":       ("検査説明",           ""),
    "SeriesDescription":      ("シリーズ説明",       ""),
}

TEXT_EXTS = {".csv", ".txt", ".tsv", ".log", ".ini", ".yaml", ".yml", ".toml", ".bin"}
RICH_EXTS = {".json", ".xml"}
XLSX_EXT = ".xlsx"
OOXML_EXTS = {".docx", ".pptx"}
MAPPING_CSV = "_対応表.csv"

# 親DIR直下ファイル: 名前列検出キーワード (正規化後: 小文字, 区切り除去)
_NAME_KW_STRONG = ('患者名', 'patientname', '被験者名', '対象者名',
                   '氏名', '名前', '姓名')
_NAME_KW_MEDIUM = ('lastname', 'firstname', 'familyname', 'givenname',
                   'カナ', 'フリガナ', 'ふりがな', 'ローマ字', 'romaji', 'kana')
_NAME_KW_EXACT = frozenset({'姓', '名', 'name', 'last', 'first'})
# ID列: ヘッダ不要、値ベースで既知IDとの一致率 + 日付除外 で判定
_DATE_YYYYMMDD = re.compile(
    r'^(19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])$')
_DATE_SERIAL_MAX = 73000   # Excel日付シリアル上限 (~2100年)

OUT_APP = "app"
OUT_ORIG = "orig"
OUT_CUSTOM = "custom"

# カラーパレット
CLR_ACCENT = ("#3B82F6", "#60A5FA")          # アクセントカラー
CLR_SUCCESS = ("#22C55E", "#4ADE80")         # 成功
CLR_PROCESSING = ("#F59E0B", "#FBBF24")      # 処理中

# ゾーンカラー
CLR_LEFT_BG      = ("#EDF2FB", "#1A2540")    # 左ゾーン背景 (淡い青)
CLR_LEFT_BORDER  = ("#B8CCE5", "#3A4F6F")    # 左ゾーン枠
CLR_RIGHT_BG     = ("#F2EDF8", "#251A40")    # 右ゾーン背景 (淡い紫)
CLR_RIGHT_BORDER = ("#C5B8E5", "#4F3A6F")    # 右ゾーン枠
CLR_ZONE_SELECTED_BG = ("#DBEAFE", "#1E3A5F")  # 選択時の青背景
CLR_DONE_BG          = ("#DCFCE7", "#14532D")   # 完了時の緑背景
CLR_ARROW_DISABLED   = ("#D1D5DB", "#374151")   # 矢印無効色
CLR_CENTER_BG        = ("#F8F9FB", "#1E2030")   # 中央ゾーン背景

ICON_LOCK_OPEN   = "\U0001F513"   # 🔓
ICON_LOCK_CLOSED = "\U0001F512"   # 🔒
ICON_ARROW_RIGHT = "\u27A1"       # ➡
ICON_ARROW_LEFT  = "\u2B05"       # ⬅


# ============================================================
# 暗号化SEED値 作成ダイアログ
# ============================================================

class PasswordDialog(ctk.CTkToplevel):

    def __init__(self, parent, on_saved=None):
        super().__init__(parent)
        self.title("暗号化SEED値 新規作成")
        self.geometry("520x400")
        self.transient(parent)
        self.grab_set()
        self.on_saved = on_saved

        self.after(100, self.lift)

        # 説明
        ctk.CTkLabel(
            self,
            text="暗号化SEED値を自動生成します。\n"
                 "生成されたSEED値は SEED.conf に保存されます。",
            font=("", 12), justify="left"
        ).pack(anchor="w", padx=20, pady=(15, 5))

        # 警告
        ctk.CTkLabel(
            self,
            text="* SEED値を変更すると、過去の匿名化結果とは異なる結果になります\n"
                 "* SEED.conf を匿名化データと一緒に配布しないでください",
            font=("", 11), text_color="orange", justify="left"
        ).pack(anchor="w", padx=20, pady=(0, 10))

        # SEED値表示
        pw_frame = ctk.CTkFrame(self, fg_color="transparent")
        pw_frame.pack(fill="x", padx=20)
        ctk.CTkLabel(pw_frame, text="暗号化SEED値:", font=("", 12)).pack(anchor="w")

        pw_row = ctk.CTkFrame(pw_frame, fg_color="transparent")
        pw_row.pack(fill="x", pady=(2, 0))
        self.pw_var = tk.StringVar(value=_generate_password())
        self.pw_entry = ctk.CTkEntry(
            pw_row, textvariable=self.pw_var, width=340,
            font=("Consolas", 13)
        )
        self.pw_entry.pack(side="left")
        ctk.CTkButton(
            pw_row, text="再生成", width=70,
            fg_color="gray", hover_color="#555",
            command=self._regenerate
        ).pack(side="left", padx=(8, 0))

        # 強度表示
        self.strength_label = ctk.CTkLabel(
            self, text="", font=("", 11), anchor="w"
        )
        self.strength_label.pack(fill="x", padx=20, pady=(4, 8))
        self._update_strength()
        self.pw_var.trace_add("write", lambda *_: self._update_strength())

        # メモ
        memo_frame = ctk.CTkFrame(self, fg_color="transparent")
        memo_frame.pack(fill="x", padx=20)
        ctk.CTkLabel(memo_frame, text="メモ (任意):", font=("", 12)).pack(anchor="w")
        self.memo_box = ctk.CTkTextbox(memo_frame, height=80, font=("", 11))
        self.memo_box.pack(fill="x", pady=(2, 0))

        # ボタン
        btn_row = ctk.CTkFrame(self, fg_color="transparent")
        btn_row.pack(fill="x", padx=20, pady=15)
        ctk.CTkButton(
            btn_row, text="保存して適用", width=140,
            command=self._save
        ).pack(side="left")
        ctk.CTkButton(
            btn_row, text="キャンセル", width=100,
            fg_color="gray", hover_color="#555",
            command=self.destroy
        ).pack(side="right")

    def _regenerate(self):
        self.pw_var.set(_generate_password())

    def _update_strength(self):
        pw = self.pw_var.get()
        ent = _estimate_entropy(pw)
        crack = _crack_time_display(ent)
        if ent >= MIN_ENTROPY_BITS:
            self.strength_label.configure(
                text=f"強度: {ent:.0f} bit / 推定解読時間: {crack}",
                text_color="green"
            )
        else:
            self.strength_label.configure(
                text=f"強度: {ent:.0f} bit / 推定解読時間: {crack} (不足)",
                text_color="red"
            )

    def _save(self):
        pw = self.pw_var.get().strip()
        if not pw:
            messagebox.showerror("エラー", "SEED値が空です", parent=self)
            return
        ent = _estimate_entropy(pw)
        if ent < MIN_ENTROPY_BITS:
            if not messagebox.askyesno(
                "強度不足",
                f"SEED値の強度が {ent:.0f} bit で基準 ({MIN_ENTROPY_BITS} bit) を下回っています。\n"
                "このまま保存しますか？",
                parent=self
            ):
                return
        memo = self.memo_box.get("1.0", "end").strip()
        # 親ウィンドウから現在の設定を収集して一緒に保存
        settings = None
        if hasattr(self.master, "_collect_settings"):
            settings = self.master._collect_settings()
        _save_password_file(pw, memo, settings)

        global SEED
        SEED = pw

        if self.on_saved:
            self.on_saved(pw)

        messagebox.showinfo(
            "保存完了",
            f"SEED.conf に保存しました。\n\n"
            f"場所: {_SEED_FILE}\n"
            f"強度: {ent:.0f} bit / 推定解読時間: {_crack_time_display(ent)}",
            parent=self
        )
        self.destroy()


# ============================================================
# DICOM 詳細設定ダイアログ
# ============================================================

class DicomSettingsDialog(ctk.CTkToplevel):

    def __init__(self, parent, tag_vars, tag_entries):
        super().__init__(parent)
        self.title("DICOM 匿名化 詳細設定")
        self.geometry("580x540")
        self.transient(parent)
        self.grab_set()

        self.after(100, self.lift)

        ctk.CTkLabel(
            self, text="{id} は匿名化 ID に自動置換されます",
            font=("", 11), text_color="gray"
        ).pack(anchor="w", padx=15, pady=(10, 5))

        scroll = ctk.CTkScrollableFrame(self, height=420)
        scroll.pack(fill="both", expand=True, padx=10, pady=5)

        for tag_name, (display, _) in DEFAULT_DICOM_TAGS.items():
            row = ctk.CTkFrame(scroll, fg_color="transparent")
            row.pack(fill="x", pady=2)

            ctk.CTkCheckBox(
                row, text=f"{display} ({tag_name})",
                variable=tag_vars[tag_name], width=320,
                onvalue=True, offvalue=False
            ).pack(side="left")

            ctk.CTkEntry(
                row, textvariable=tag_entries[tag_name], width=150
            ).pack(side="right", padx=5)

        ctk.CTkButton(self, text="閉じる", width=100,
                      command=self.destroy).pack(pady=10)


# ============================================================
# シナリオB用: 新規ID割当方法ダイアログ
# ============================================================

class NewIdAssignDialog(ctk.CTkToplevel):
    """既存対応表がある場合に新規IDの割当方法を選択するダイアログ"""

    def __init__(self, parent, existing_count, new_count, next_preview, current_template):
        super().__init__(parent)
        self.title("新規IDの割当方法")
        self.geometry("440x300")
        self.transient(parent)
        self.grab_set()
        self.result = None  # "continue" / "change" / None(cancel)
        self.new_template = None

        self.after(100, self.lift)

        ctk.CTkLabel(
            self, text=f"既存対応表: {existing_count} 件\n新規ID: {new_count} 件",
            font=("", 13), justify="left"
        ).pack(anchor="w", padx=20, pady=(15, 10))

        self._choice = tk.StringVar(value="continue")

        ctk.CTkRadioButton(
            self, text=f"同じパターンで続行 (次: {next_preview}〜)",
            variable=self._choice, value="continue",
            command=self._on_choice
        ).pack(anchor="w", padx=20, pady=(5, 2))

        ctk.CTkRadioButton(
            self, text="ヘッダーテキストを変更",
            variable=self._choice, value="change",
            command=self._on_choice
        ).pack(anchor="w", padx=20, pady=(2, 2))

        self._tmpl_var = tk.StringVar(value=current_template)
        self._tmpl_entry = ctk.CTkEntry(
            self, textvariable=self._tmpl_var, width=300,
            placeholder_text="新しいテンプレート例: KMS_{0001}_aaa"
        )
        self._tmpl_entry.pack(anchor="w", padx=40, pady=(2, 10))
        self._tmpl_entry.configure(state="disabled")

        btn_row = ctk.CTkFrame(self, fg_color="transparent")
        btn_row.pack(fill="x", padx=20, pady=15)
        ctk.CTkButton(
            btn_row, text="OK", width=120, command=self._ok
        ).pack(side="left")
        ctk.CTkButton(
            btn_row, text="キャンセル", width=100,
            fg_color="gray", hover_color="#555", command=self._cancel
        ).pack(side="right")

        self.protocol("WM_DELETE_WINDOW", self._cancel)

    def _on_choice(self):
        if self._choice.get() == "change":
            self._tmpl_entry.configure(state="normal")
        else:
            self._tmpl_entry.configure(state="disabled")

    def _ok(self):
        if self._choice.get() == "change":
            self.result = "change"
            self.new_template = self._tmpl_var.get().strip()
            if not self.new_template:
                messagebox.showerror("エラー", "テンプレートを入力してください", parent=self)
                return
        else:
            self.result = "continue"
        self.grab_release()
        self.destroy()

    def _cancel(self):
        self.result = None
        self.grab_release()
        self.destroy()


# ============================================================
# メインアプリケーション
# ============================================================

class AnonymizerApp(ctk.CTk):

    def __init__(self):
        super().__init__()

        ctk.set_appearance_mode("System")
        ctk.set_default_color_theme("blue")

        self.title("匿名化ツール")
        self.geometry("480x290")
        self.resizable(True, True)

        if not SEED:
            self.after(200, lambda: messagebox.showwarning(
                "暗号化SEED値 未設定",
                "SEED.conf が見つからないか空です。\n"
                "アプリと同じフォルダに SEED.conf を作成し、\n"
                "暗号化SEED値を記入してください。\n\n"
                "【必要な文字数の目安】\n" + _password_guidance()
            ))
        elif _estimate_entropy(SEED) < MIN_ENTROPY_BITS:
            ent = _estimate_entropy(SEED)
            crack = _crack_time_display(ent)
            self.after(200, lambda: messagebox.showwarning(
                "暗号化SEED値が短すぎます",
                f"現在のSEED値の強度: {ent:.0f} bit\n"
                f"推定解読時間: {crack}\n"
                f"(必要強度: {MIN_ENTROPY_BITS} bit 以上 = 100年以上)\n\n"
                "【必要な文字数の目安】\n" + _password_guidance() + "\n\n"
                "SEED.conf のSEED値を変更してください。"
            ))
        self.key = derive_key(SEED)
        self.processing = False
        self.last_output_dir = None

        # 双方向ドロップゾーン状態
        self._ui_state = "idle"
        self._left_path = None           # 左に選択されたフォルダ
        self._right_path = None          # 右に選択されたフォルダ
        self._left_output_dir = None     # 復元結果の出力先
        self._right_output_dir = None    # 匿名化結果の出力先
        self._single_id_filter = None    # 単独IDフォルダ名 (例: "1234567_CT")

        # スレッドセーフなコールバックキュー
        self._callback_queue = queue.Queue()

        # DICOM タグ設定
        self.tag_vars = {}
        self.tag_entries = {}
        for tag_name, (_, default) in DEFAULT_DICOM_TAGS.items():
            self.tag_vars[tag_name] = tk.BooleanVar(value=True)
            self.tag_entries[tag_name] = tk.StringVar(value=default)

        self._build_ui()
        self._setup_dnd()
        self._poll_callback_queue()  # キューポーリング開始

        # SEED.conf から設定を復元
        if _LOADED_SETTINGS:
            self._apply_settings(_LOADED_SETTINGS)

    # --------------------------------------------------------
    # 設定の収集 / 適用 / 保存
    # --------------------------------------------------------

    def _collect_settings(self) -> dict:
        """現在のGUI設定を辞書に収集"""
        settings = {
            "anonymization": {
                "id_digits": self.id_digits.get(),
                "anon_mode": self.anon_mode.get(),
                "prefix": self.prefix.get(),
                "simple_text": self.simple_text.get(),
                "dicom_replace_text": self.dicom_replace_text.get(),
            },
            "options": {
                "opt_rename": str(self.opt_rename.get()).lower(),
                "opt_text": str(self.opt_text.get()).lower(),
                "opt_dicom": str(self.opt_dicom.get()).lower(),
            },
            "output": {
                "output_mode": self.output_mode.get(),
                "custom_dir": self.custom_dir.get(),
            },
            "dicom_tags": {},
        }
        for tag_name in DEFAULT_DICOM_TAGS:
            enabled = str(self.tag_vars[tag_name].get()).lower()
            value = self.tag_entries[tag_name].get()
            settings["dicom_tags"][tag_name] = f"{enabled}|{value}"
        return settings

    def _apply_settings(self, settings: dict):
        """辞書からGUI設定を復元"""
        anon = settings.get("anonymization", {})
        if "id_digits" in anon and anon["id_digits"] in ("5", "6", "7", "8"):
            self.id_digits.set(anon["id_digits"])
        if "anon_mode" in anon and anon["anon_mode"] in ("feistel", "simple", "dicom_only"):
            self.anon_mode.set(anon["anon_mode"])
        if "prefix" in anon:
            self.prefix.set(anon["prefix"])
        if "simple_text" in anon:
            self.simple_text.set(anon["simple_text"])
        if "dicom_replace_text" in anon:
            self.dicom_replace_text.set(anon["dicom_replace_text"])

        opts = settings.get("options", {})
        if "opt_rename" in opts:
            self.opt_rename.set(opts["opt_rename"] == "true")
        if "opt_text" in opts:
            self.opt_text.set(opts["opt_text"] == "true")
        if "opt_dicom" in opts:
            self.opt_dicom.set(opts["opt_dicom"] == "true")

        out = settings.get("output", {})
        if "output_mode" in out and out["output_mode"] in (OUT_APP, OUT_ORIG, OUT_CUSTOM):
            self.output_mode.set(out["output_mode"])
        if "custom_dir" in out:
            self.custom_dir.set(out["custom_dir"])

        dtags = settings.get("dicom_tags", {})
        for tag_name, value in dtags.items():
            if tag_name in self.tag_vars:
                parts = value.split("|", 1)
                self.tag_vars[tag_name].set(parts[0] == "true")
                if len(parts) > 1:
                    self.tag_entries[tag_name].set(parts[1])

        self._on_mode_change()

    def _save_current_settings(self):
        """現在のGUI設定をSEED.confに保存（SEED値は変更しない）"""
        if not _SEED_FILE.exists():
            return
        pw, memo, _ = _load_password_file()
        _save_password_file(pw, memo, self._collect_settings())

    # --------------------------------------------------------
    # UI 構築
    # --------------------------------------------------------

    def _build_ui(self):
        # === ヘッダー ===
        header = ctk.CTkFrame(self, fg_color="transparent")
        header.pack(fill="x", padx=20, pady=(12, 0))

        ctk.CTkLabel(
            header, text="匿名化ツール",
            font=("", 22, "bold")
        ).pack(side="left")

        # 詳細設定トグル
        self._compact = True
        self.toggle_btn = ctk.CTkButton(
            header, text="▽ 詳細設定", width=90, height=28,
            fg_color="transparent", border_width=1,
            text_color=CLR_ACCENT, border_color=CLR_ACCENT,
            hover_color=("#E0EAFF", "#1E293B"),
            command=self._toggle_compact,
            font=("", 11),
        )
        self.toggle_btn.pack(side="right")

        if SEED and _SEED_FILE.exists():
            # SEED.conf が存在 → 押し込まれた(使用済み)見た目で無効化
            self.pw_btn = ctk.CTkButton(
                header, text="SEED値 設定済", width=120,
                fg_color=("#D1D5DB", "#374151"),
                text_color=("#9CA3AF", "#6B7280"),
                border_width=0,
                hover_color=("#D1D5DB", "#374151"),
                state="disabled",
            )
        else:
            # SEED.conf が無い → 飛び出した(未設定)目立つ見た目
            self.pw_btn = ctk.CTkButton(
                header, text="SEED値 作成", width=120,
                fg_color=CLR_ACCENT,
                text_color="white",
                border_width=2, border_color=CLR_ACCENT,
                hover_color=("#2563EB", "#3B82F6"),
                command=self._open_password_dialog,
            )
        self.pw_btn.pack(side="right", padx=(0, 8))

        # === Full view wrapper (詳細設定、初期非表示) ===
        self._full_frame = ctk.CTkFrame(self, fg_color="transparent")

        # === ドロップゾーン (3パネル: 左 | 中央矢印 | 右) ===
        drop_container = ctk.CTkFrame(
            self._full_frame, height=170, fg_color="transparent",
        )
        drop_container.pack(fill="x", padx=20, pady=(12, 8))
        drop_container.pack_propagate(False)

        # --- 左ゾーン (元データ) ---
        self.left_zone = ctk.CTkFrame(
            drop_container, corner_radius=16,
            border_width=2, border_color=CLR_LEFT_BORDER,
            fg_color=CLR_LEFT_BG,
        )
        self.left_zone.pack(side="left", fill="both", expand=True)

        left_inner = ctk.CTkFrame(self.left_zone, fg_color="transparent")
        left_inner.place(relx=0.5, rely=0.5, anchor="center")

        self.left_icon = ctk.CTkLabel(
            left_inner, text=ICON_LOCK_OPEN,
            font=("Segoe UI Emoji", 36)
        )
        self.left_icon.pack()
        self.left_text = ctk.CTkLabel(
            left_inner, text="元データ",
            font=("", 13, "bold")
        )
        self.left_text.pack(pady=(2, 0))
        self.left_sub = ctk.CTkLabel(
            left_inner, text="クリックして選択",
            font=("", 10), text_color="gray"
        )
        self.left_sub.pack()

        for w in [self.left_zone, left_inner, self.left_icon,
                  self.left_text, self.left_sub]:
            w.bind("<Button-1>", lambda e: self._on_left_click())

        # --- 中央ゾーン (矢印) ---
        self.center_zone = ctk.CTkFrame(
            drop_container, width=120, fg_color=CLR_CENTER_BG,
            corner_radius=12,
        )
        self.center_zone.pack(side="left", fill="y", padx=4)
        self.center_zone.pack_propagate(False)

        center_inner = ctk.CTkFrame(self.center_zone, fg_color="transparent")
        center_inner.place(relx=0.5, rely=0.5, anchor="center")

        self.arrow_right_btn = ctk.CTkButton(
            center_inner, text=ICON_ARROW_RIGHT, width=60, height=40,
            font=("", 22), corner_radius=10,
            fg_color=CLR_ARROW_DISABLED,
            text_color=("gray", "gray"),
            hover=False, state="disabled",
            command=self._on_arrow_right,
        )
        self.arrow_right_btn.pack(pady=(0, 8))

        self.arrow_left_btn = ctk.CTkButton(
            center_inner, text=ICON_ARROW_LEFT, width=60, height=40,
            font=("", 22), corner_radius=10,
            fg_color=CLR_ARROW_DISABLED,
            text_color=("gray", "gray"),
            hover=False, state="disabled",
            command=self._on_arrow_left,
        )
        self.arrow_left_btn.pack(pady=(8, 0))

        # --- 右ゾーン (匿名化データ) ---
        self.right_zone = ctk.CTkFrame(
            drop_container, corner_radius=16,
            border_width=2, border_color=CLR_RIGHT_BORDER,
            fg_color=CLR_RIGHT_BG,
        )
        self.right_zone.pack(side="left", fill="both", expand=True)

        right_inner = ctk.CTkFrame(self.right_zone, fg_color="transparent")
        right_inner.place(relx=0.5, rely=0.5, anchor="center")

        self.right_icon = ctk.CTkLabel(
            right_inner, text=ICON_LOCK_CLOSED,
            font=("Segoe UI Emoji", 36)
        )
        self.right_icon.pack()
        self.right_text = ctk.CTkLabel(
            right_inner, text="匿名化データ",
            font=("", 13, "bold")
        )
        self.right_text.pack(pady=(2, 0))
        self.right_sub = ctk.CTkLabel(
            right_inner, text="クリックして選択",
            font=("", 10), text_color="gray"
        )
        self.right_sub.pack()

        for w in [self.right_zone, right_inner, self.right_icon,
                  self.right_text, self.right_sub]:
            w.bind("<Button-1>", lambda e: self._on_right_click())

        # === 出力先設定 ===
        out_section = ctk.CTkFrame(self._full_frame, fg_color="transparent")
        out_section.pack(fill="x", padx=20, pady=(0, 4))

        ctk.CTkLabel(out_section, text="出力先",
                     font=("", 14, "bold")).pack(anchor="w")

        self.output_mode = tk.StringVar(value=OUT_ORIG)

        radio_row = ctk.CTkFrame(out_section, fg_color="transparent")
        radio_row.pack(fill="x")

        ctk.CTkRadioButton(
            radio_row, text="アプリと同じ場所",
            variable=self.output_mode, value=OUT_APP
        ).pack(side="left", padx=(0, 12))

        ctk.CTkRadioButton(
            radio_row, text="元フォルダと同じ場所",
            variable=self.output_mode, value=OUT_ORIG
        ).pack(side="left", padx=12)

        ctk.CTkRadioButton(
            radio_row, text="指定した場所",
            variable=self.output_mode, value=OUT_CUSTOM
        ).pack(side="left", padx=12)

        custom_row = ctk.CTkFrame(out_section, fg_color="transparent")
        custom_row.pack(fill="x", pady=(4, 0))

        self.custom_dir = tk.StringVar()
        ctk.CTkEntry(
            custom_row, textvariable=self.custom_dir, width=300,
            placeholder_text="出力先フォルダを選択..."
        ).pack(side="left")

        ctk.CTkButton(
            custom_row, text="参照", width=60,
            fg_color="gray", hover_color="#555",
            command=self._browse_output
        ).pack(side="left", padx=6)

        self.open_btn = ctk.CTkButton(
            custom_row, text="出力フォルダを開く", width=140,
            state="disabled", command=self._open_output
        )
        self.open_btn.pack(side="right")

        # === 匿名化設定 ===
        anon_section = ctk.CTkFrame(self._full_frame, fg_color="transparent")
        anon_section.pack(fill="x", padx=20, pady=(4, 4))

        ctk.CTkLabel(anon_section, text="匿名化設定",
                     font=("", 14, "bold")).pack(anchor="w")

        # ID桁数
        digits_row = ctk.CTkFrame(anon_section, fg_color="transparent")
        digits_row.pack(fill="x", pady=2)
        ctk.CTkLabel(digits_row, text="ID桁数:", font=("", 12)).pack(side="left")
        self.id_digits = tk.StringVar(value="7")
        self.digits_seg = ctk.CTkSegmentedButton(
            digits_row, values=["5", "6", "7", "8"],
            variable=self.id_digits, width=200
        )
        self.digits_seg.pack(side="left", padx=(8, 0))

        # モード選択
        mode_row = ctk.CTkFrame(anon_section, fg_color="transparent")
        mode_row.pack(fill="x", pady=2)
        ctk.CTkLabel(mode_row, text="モード:", font=("", 12)).pack(side="left")
        self.anon_mode = tk.StringVar(value="feistel")
        ctk.CTkRadioButton(
            mode_row, text="Feistel暗号化",
            variable=self.anon_mode, value="feistel",
            command=self._on_mode_change
        ).pack(side="left", padx=(8, 12))
        ctk.CTkRadioButton(
            mode_row, text="対応表作成",
            variable=self.anon_mode, value="simple",
            command=self._on_mode_change
        ).pack(side="left", padx=12)
        ctk.CTkRadioButton(
            mode_row, text="DICOMタグのみ",
            variable=self.anon_mode, value="dicom_only",
            command=self._on_mode_change
        ).pack(side="left", padx=12)

        # 接頭辞 (Feistelモード用)
        self._prefix_row = ctk.CTkFrame(anon_section, fg_color="transparent")
        self._prefix_row.pack(fill="x", pady=2)
        ctk.CTkLabel(self._prefix_row, text="接頭辞:", font=("", 12)).pack(side="left")
        self.prefix = tk.StringVar(value="K")
        self.prefix_entry = ctk.CTkEntry(
            self._prefix_row, textvariable=self.prefix, width=120
        )
        self.prefix_entry.pack(side="left", padx=(8, 0))

        # 対応表ルール (対応表モード用)
        self._simple_row = ctk.CTkFrame(anon_section, fg_color="transparent")
        ctk.CTkLabel(self._simple_row, text="対応表ルール:", font=("", 12)).pack(side="left")
        self.simple_text = tk.StringVar(value="tokumeika")
        self.simple_entry = ctk.CTkEntry(
            self._simple_row, textvariable=self.simple_text, width=200,
            placeholder_text="例: KMS_{0001}_aaa"
        )
        self.simple_entry.pack(side="left", padx=(8, 0))
        ctk.CTkLabel(
            self._simple_row,
            text="{0013}で0013,0014,0015...",
            font=("", 11), text_color="gray",
        ).pack(side="left", padx=(8, 0))

        # 置換テキスト (DICOMタグのみモード用)
        self._dicom_text_row = ctk.CTkFrame(anon_section, fg_color="transparent")
        ctk.CTkLabel(self._dicom_text_row, text="置換テキスト:", font=("", 12)).pack(side="left")
        self.dicom_replace_text = tk.StringVar(value="anonymous")
        ctk.CTkEntry(
            self._dicom_text_row, textvariable=self.dicom_replace_text, width=200,
            placeholder_text="例: anonymous"
        ).pack(side="left", padx=(8, 0))

        # === 処理オプション ===
        opt_section = ctk.CTkFrame(self._full_frame, fg_color="transparent")
        opt_section.pack(fill="x", padx=20, pady=(4, 4))

        ctk.CTkLabel(opt_section, text="処理オプション",
                     font=("", 14, "bold")).pack(anchor="w")

        opts = ctk.CTkFrame(opt_section, fg_color="transparent")
        opts.pack(fill="x")

        self.opt_rename = tk.BooleanVar(value=True)
        ctk.CTkCheckBox(
            opts, text="フォルダ名・ファイル名の ID 置換",
            variable=self.opt_rename, onvalue=True, offvalue=False
        ).pack(anchor="w", pady=1)

        self.opt_text = tk.BooleanVar(value=True)
        ctk.CTkCheckBox(
            opts, text="ファイル内 ID 置換 (.csv .txt .tsv .json .xml .xlsx)",
            variable=self.opt_text, onvalue=True, offvalue=False
        ).pack(anchor="w", pady=1)

        dcm_row = ctk.CTkFrame(opts, fg_color="transparent")
        dcm_row.pack(fill="x", pady=1)

        self.opt_dicom = tk.BooleanVar(value=HAS_PYDICOM)
        dcm_chk = ctk.CTkCheckBox(
            dcm_row, text="DICOM タグ匿名化",
            variable=self.opt_dicom, onvalue=True, offvalue=False
        )
        dcm_chk.pack(side="left")

        if HAS_PYDICOM:
            ctk.CTkButton(
                dcm_row, text="詳細設定", width=80,
                fg_color="gray", hover_color="#555",
                command=self._open_dicom_settings
            ).pack(side="left", padx=10)
        else:
            dcm_chk.configure(state="disabled")
            ctk.CTkLabel(
                dcm_row, text="(pydicom 未インストール)",
                text_color="red", font=("", 11)
            ).pack(side="left", padx=10)

        # === プログレス ===
        prog_section = ctk.CTkFrame(self._full_frame, fg_color="transparent")
        prog_section.pack(fill="x", padx=20, pady=(6, 2))

        self.progress = ctk.CTkProgressBar(prog_section, height=12)
        self.progress.pack(fill="x")
        self.progress.set(0)

        self.status_label = ctk.CTkLabel(
            prog_section, text="待機中...", font=("", 11), anchor="w"
        )
        self.status_label.pack(fill="x", pady=(2, 0))

        # === ログ ===
        log_section = ctk.CTkFrame(self._full_frame, fg_color="transparent")
        log_section.pack(fill="both", expand=True, padx=20, pady=(2, 4))

        ctk.CTkLabel(log_section, text="ログ",
                     font=("", 14, "bold")).pack(anchor="w")

        self.log_box = ctk.CTkTextbox(
            log_section, font=("Consolas", 10), state="disabled", height=120
        )
        self.log_box.pack(fill="both", expand=True)

        # === フッター ===
        ctk.CTkLabel(
            self._full_frame,
            text="Feistel cipher  (PBKDF2-SHA256 + HMAC-SHA256, 16 rounds)  |  ID-Anonymizer.ps1 互換",
            font=("", 9), text_color="gray"
        ).pack(pady=(0, 6))

        # === コンパクトビュー (デフォルト表示) ===
        self._compact_frame = ctk.CTkFrame(self, fg_color="transparent")
        self._build_compact_view()
        self._compact_frame.pack(fill="both", expand=True)

    def _build_compact_view(self):
        """コンパクトビュー: 3パネルドロップゾーン + 開くボタン"""
        body = ctk.CTkFrame(self._compact_frame, fg_color="transparent")
        body.pack(fill="both", expand=True, padx=10, pady=(8, 10))

        # --- 3パネル ドロップゾーン ---
        c_drop_container = ctk.CTkFrame(body, height=140, fg_color="transparent")
        c_drop_container.pack(fill="x")
        c_drop_container.pack_propagate(False)

        # 左ゾーン
        self._c_left_zone = ctk.CTkFrame(
            c_drop_container, corner_radius=12,
            border_width=2, border_color=CLR_LEFT_BORDER,
            fg_color=CLR_LEFT_BG,
        )
        self._c_left_zone.pack(side="left", fill="both", expand=True)

        c_left_inner = ctk.CTkFrame(self._c_left_zone, fg_color="transparent")
        c_left_inner.place(relx=0.5, rely=0.5, anchor="center")

        self._c_left_icon = ctk.CTkLabel(
            c_left_inner, text=ICON_LOCK_OPEN, font=("Segoe UI Emoji", 28)
        )
        self._c_left_icon.pack()
        self._c_left_text = ctk.CTkLabel(
            c_left_inner, text="元データ",
            font=("", 11, "bold")
        )
        self._c_left_text.pack(pady=(1, 0))
        self._c_left_sub = ctk.CTkLabel(
            c_left_inner, text="クリックして選択",
            font=("", 9), text_color="gray"
        )
        self._c_left_sub.pack()

        for w in [self._c_left_zone, c_left_inner, self._c_left_icon,
                  self._c_left_text, self._c_left_sub]:
            w.bind("<Button-1>", lambda e: self._on_left_click())

        # 中央ゾーン (矢印)
        self._c_center_zone = ctk.CTkFrame(
            c_drop_container, width=60, fg_color=CLR_CENTER_BG,
            corner_radius=8,
        )
        self._c_center_zone.pack(side="left", fill="y", padx=2)
        self._c_center_zone.pack_propagate(False)

        c_center_inner = ctk.CTkFrame(self._c_center_zone, fg_color="transparent")
        c_center_inner.place(relx=0.5, rely=0.5, anchor="center")

        self._c_arrow_right_btn = ctk.CTkButton(
            c_center_inner, text=ICON_ARROW_RIGHT, width=44, height=32,
            font=("", 18), corner_radius=8,
            fg_color=CLR_ARROW_DISABLED,
            text_color=("gray", "gray"),
            hover=False, state="disabled",
            command=self._on_arrow_right,
        )
        self._c_arrow_right_btn.pack(pady=(0, 4))

        self._c_arrow_left_btn = ctk.CTkButton(
            c_center_inner, text=ICON_ARROW_LEFT, width=44, height=32,
            font=("", 18), corner_radius=8,
            fg_color=CLR_ARROW_DISABLED,
            text_color=("gray", "gray"),
            hover=False, state="disabled",
            command=self._on_arrow_left,
        )
        self._c_arrow_left_btn.pack(pady=(4, 0))

        # 右ゾーン
        self._c_right_zone = ctk.CTkFrame(
            c_drop_container, corner_radius=12,
            border_width=2, border_color=CLR_RIGHT_BORDER,
            fg_color=CLR_RIGHT_BG,
        )
        self._c_right_zone.pack(side="left", fill="both", expand=True)

        c_right_inner = ctk.CTkFrame(self._c_right_zone, fg_color="transparent")
        c_right_inner.place(relx=0.5, rely=0.5, anchor="center")

        self._c_right_icon = ctk.CTkLabel(
            c_right_inner, text=ICON_LOCK_CLOSED, font=("Segoe UI Emoji", 28)
        )
        self._c_right_icon.pack()
        self._c_right_text = ctk.CTkLabel(
            c_right_inner, text="匿名化データ",
            font=("", 11, "bold")
        )
        self._c_right_text.pack(pady=(1, 0))
        self._c_right_sub = ctk.CTkLabel(
            c_right_inner, text="クリックして選択",
            font=("", 9), text_color="gray"
        )
        self._c_right_sub.pack()

        for w in [self._c_right_zone, c_right_inner, self._c_right_icon,
                  self._c_right_text, self._c_right_sub]:
            w.bind("<Button-1>", lambda e: self._on_right_click())

        # --- モード選択 + パラメータ ---
        c_mode_row = ctk.CTkFrame(body, fg_color="transparent")
        c_mode_row.pack(fill="x", pady=(8, 0))
        ctk.CTkLabel(c_mode_row, text="モード:", font=("", 12)).pack(side="left")
        ctk.CTkRadioButton(
            c_mode_row, text="Feistel暗号化",
            variable=self.anon_mode, value="feistel",
            command=self._on_mode_change
        ).pack(side="left", padx=(8, 12))
        ctk.CTkRadioButton(
            c_mode_row, text="対応表作成",
            variable=self.anon_mode, value="simple",
            command=self._on_mode_change
        ).pack(side="left", padx=12)
        ctk.CTkRadioButton(
            c_mode_row, text="DICOMタグのみ",
            variable=self.anon_mode, value="dicom_only",
            command=self._on_mode_change
        ).pack(side="left", padx=12)

        # 接頭辞 / 対応表ルール / 置換テキスト (モードに応じて切替)
        self._c_prefix_row = ctk.CTkFrame(body, fg_color="transparent")
        ctk.CTkLabel(self._c_prefix_row, text="接頭辞:", font=("", 12)).pack(side="left")
        ctk.CTkEntry(
            self._c_prefix_row, textvariable=self.prefix, width=120
        ).pack(side="left", padx=(8, 0))

        self._c_simple_row = ctk.CTkFrame(body, fg_color="transparent")
        ctk.CTkLabel(self._c_simple_row, text="対応表ルール:", font=("", 12)).pack(side="left")
        ctk.CTkEntry(
            self._c_simple_row, textvariable=self.simple_text, width=160,
            placeholder_text="例: KMS_{0001}_aaa"
        ).pack(side="left", padx=(8, 0))
        ctk.CTkLabel(
            self._c_simple_row,
            text="{0013}で0013,0014,0015...",
            font=("", 11), text_color="gray",
        ).pack(side="left", padx=(8, 0))

        self._c_dicom_text_row = ctk.CTkFrame(body, fg_color="transparent")
        ctk.CTkLabel(self._c_dicom_text_row, text="置換テキスト:", font=("", 12)).pack(side="left")
        ctk.CTkEntry(
            self._c_dicom_text_row, textvariable=self.dicom_replace_text, width=160,
            placeholder_text="例: anonymous"
        ).pack(side="left", padx=(8, 0))

        # 初期表示
        mode = self.anon_mode.get()
        if mode == "feistel":
            self._c_prefix_row.pack(fill="x", pady=(4, 0))
        elif mode == "simple":
            self._c_simple_row.pack(fill="x", pady=(4, 0))
        elif mode == "dicom_only":
            self._c_dicom_text_row.pack(fill="x", pady=(4, 0))

    def _toggle_compact(self):
        """コンパクト表示 ↔ 詳細設定 切替"""
        self._compact = not self._compact
        if self._compact:
            self._full_frame.pack_forget()
            self._compact_frame.pack(fill="both", expand=True)
            self.toggle_btn.configure(text="▽ 詳細設定")
            self.geometry("480x290")
        else:
            self._compact_frame.pack_forget()
            self._full_frame.pack(fill="both", expand=True)
            self.toggle_btn.configure(text="△ 詳細設定")
            self.geometry("640x920")

    # --------------------------------------------------------
    # スレッドセーフなコールバック
    # --------------------------------------------------------

    def _poll_callback_queue(self):
        """キューに溜まったコールバックをメインスレッドで実行"""
        try:
            while True:
                func = self._callback_queue.get_nowait()
                func()
        except queue.Empty:
            pass
        self.after(50, self._poll_callback_queue)

    def _thread_call(self, func):
        """ワーカースレッドからメインスレッドの関数を安全に呼ぶ"""
        self._callback_queue.put(func)

    # --------------------------------------------------------
    # ドラッグ＆ドロップ
    # --------------------------------------------------------

    def _setup_dnd(self):
        if HAS_WINDND:
            windnd.hook_dropfiles(self, func=self._on_drop_raw)

    def _on_drop_raw(self, files):
        """windnd コールバック (別スレッドの可能性) → メインスレッドに転送"""
        self._thread_call(lambda: self._on_drop(files))

    def _on_drop(self, files):
        if self.processing:
            return
        paths = []
        for f in files:
            if isinstance(f, bytes):
                for enc in ("utf-8", "cp932", "mbcs"):
                    try:
                        paths.append(f.decode(enc))
                        break
                    except (UnicodeDecodeError, LookupError):
                        continue
            else:
                paths.append(str(f))
        if not paths:
            return
        path = paths[0]
        if not os.path.isdir(path):
            messagebox.showerror("エラー", "フォルダをドロップしてください")
            return

        mode = self.anon_mode.get()

        # dicom_onlyモード: 任意のフォルダを左ゾーンに受け入れ
        if mode == "dicom_only":
            self._single_id_filter = None
            self._select_left(path)
            return

        # フォルダ内容から方向を自動判別
        id_digits = int(self.id_digits.get())
        prefix = self.prefix.get()
        _, out_digits = get_cipher_params(id_digits)

        orig_pattern = re.compile(r"^\d{" + str(id_digits) + r"}(?!\d)")
        anon_pattern = re.compile(
            r"^" + re.escape(prefix) + r"\d{" + str(out_digits) + r"}(?!\d)"
        )

        # ドロップされたフォルダ名自体がIDパターンに一致するかチェック
        folder_name = Path(path).name
        if orig_pattern.match(folder_name):
            self._single_id_filter = folder_name
            self._select_left(str(Path(path).parent))
            return

        subdirs = [d.name for d in Path(path).iterdir() if d.is_dir()]
        has_orig = any(orig_pattern.match(n) for n in subdirs)
        has_anon = any(anon_pattern.match(n) for n in subdirs)
        has_mapping = (Path(path) / MAPPING_CSV).exists()

        if has_orig:
            self._single_id_filter = None
            self._select_left(path)
        elif has_anon or has_mapping:
            self._single_id_filter = None
            self._select_right(path)
        else:
            messagebox.showerror(
                "エラー",
                f"対象サブフォルダが見つかりません。\n"
                f"元ID ({id_digits}桁) または 匿名化ID "
                f"({prefix}+{out_digits}桁) のサブフォルダを含む\n"
                f"フォルダをドロップしてください。"
            )

    # --------------------------------------------------------
    # ゾーンクリック / 選択 / 矢印
    # --------------------------------------------------------

    def _on_left_click(self):
        if self.processing:
            return
        if self._ui_state == "done_reverse":
            # 完了ゾーンクリック → 出力フォルダを開く
            if self._left_output_dir and os.path.isdir(self._left_output_dir):
                os.startfile(self._left_output_dir)
            return
        if self._ui_state in ("processing_fwd", "processing_rev"):
            return
        # idle, left_selected, right_selected, done_forward → 新規選択
        path = filedialog.askdirectory(title="元データフォルダを選択")
        if path:
            self._single_id_filter = None
            self._select_left(path)

    def _on_right_click(self):
        if self.processing:
            return
        if self._ui_state == "done_forward":
            # 完了ゾーンクリック → 出力フォルダを開く
            if self._right_output_dir and os.path.isdir(self._right_output_dir):
                os.startfile(self._right_output_dir)
            return
        if self._ui_state in ("processing_fwd", "processing_rev"):
            return
        # idle, left_selected, right_selected, done_reverse → 新規選択
        path = filedialog.askdirectory(title="匿名化データフォルダを選択")
        if path:
            self._select_right(path)

    def _select_left(self, path):
        self._left_path = path
        self._right_path = None
        self._set_ui_state("left_selected")

    def _select_right(self, path):
        self._right_path = path
        self._left_path = None
        self._set_ui_state("right_selected")

    def _on_arrow_right(self):
        if self._ui_state != "left_selected" or not self._left_path:
            return
        self._start_processing_forward(self._left_path)

    def _on_arrow_left(self):
        if self._ui_state != "right_selected" or not self._right_path:
            return
        mode = self.anon_mode.get()
        if mode == "feistel":
            self._start_processing_reverse(self._right_path)
        elif mode == "simple":
            csv_path = Path(self._right_path) / MAPPING_CSV
            if csv_path.exists():
                self._start_processing_reverse_simple(self._right_path, csv_path)

    # --------------------------------------------------------
    # 出力先
    # --------------------------------------------------------

    def _get_dst_root(self, src_root: str, direction: str = "forward") -> str:
        suffix = "_anon" if direction == "forward" else "_deanon"
        folder_name = Path(src_root).name + suffix
        mode = self.output_mode.get()
        if mode == OUT_APP:
            base = str(_APP_DIR)
        elif mode == OUT_ORIG:
            base = str(Path(src_root).parent)
        else:
            base = self.custom_dir.get()
            if not base or not os.path.isdir(base):
                raise ValueError("有効な出力先フォルダを指定してください")
        return os.path.join(base, folder_name)

    def _on_mode_change(self):
        mode = self.anon_mode.get()
        # フルビュー
        self._prefix_row.pack_forget()
        self._simple_row.pack_forget()
        self._dicom_text_row.pack_forget()
        if mode == "feistel":
            self._prefix_row.pack(fill="x", pady=2)
        elif mode == "simple":
            self._simple_row.pack(fill="x", pady=2)
        elif mode == "dicom_only":
            self._dicom_text_row.pack(fill="x", pady=2)
        # コンパクトビュー
        self._c_prefix_row.pack_forget()
        self._c_simple_row.pack_forget()
        self._c_dicom_text_row.pack_forget()
        if mode == "feistel":
            self._c_prefix_row.pack(fill="x", pady=(4, 0))
        elif mode == "simple":
            self._c_simple_row.pack(fill="x", pady=(4, 0))
        elif mode == "dicom_only":
            self._c_dicom_text_row.pack(fill="x", pady=(4, 0))
        # 右ゾーン選択中なら←矢印の有効/無効を更新
        if self._ui_state == "right_selected":
            self._set_ui_state("right_selected")

    def _browse_output(self):
        path = filedialog.askdirectory(title="出力先フォルダを選択")
        if path:
            self.custom_dir.set(path)
            self.output_mode.set(OUT_CUSTOM)

    def _open_output(self):
        if self.last_output_dir and os.path.isdir(self.last_output_dir):
            os.startfile(self.last_output_dir)

    # --------------------------------------------------------
    # 処理開始
    # --------------------------------------------------------

    def _check_password_strength(self) -> bool:
        """SEED値強度チェック。不足なら False"""
        ent = _estimate_entropy(SEED)
        if ent < MIN_ENTROPY_BITS:
            crack = _crack_time_display(ent)
            messagebox.showerror(
                "SEED値 強度不足",
                f"現在のSEED値では安全に暗号化できません。\n\n"
                f"強度: {ent:.0f} bit (必要: {MIN_ENTROPY_BITS} bit 以上)\n"
                f"推定解読時間: {crack} (必要: 100年以上)\n\n"
                "【必要な文字数の目安】\n" + _password_guidance() + "\n\n"
                "SEED.conf を修正してアプリを再起動してください。"
            )
            return False
        return True

    def _start_processing_forward(self, src_root: str):
        """匿名化処理開始 (元ID → 鍵ID)"""
        mode = self.anon_mode.get()

        if mode == "feistel":
            if not self._check_password_strength():
                return

        try:
            dst_root = self._get_dst_root(src_root, "forward")
        except ValueError as e:
            messagebox.showerror("エラー", str(e))
            return

        # dicom_only モード: 専用ワーカーへ分岐
        if mode == "dicom_only":
            if not HAS_PYDICOM:
                messagebox.showerror("エラー", "pydicom が必要です")
                return
            if os.path.exists(dst_root):
                if not messagebox.askyesno(
                    "確認",
                    f"出力先が既に存在します:\n{dst_root}\n\n上書きしますか？"
                ):
                    return
            dicom_tags = {}
            for tag, var in self.tag_vars.items():
                if var.get():
                    dicom_tags[tag] = self.tag_entries[tag].get()
            replace_text = self.dicom_replace_text.get()
            self._save_current_settings()
            self.processing = True
            self.progress.set(0)
            self._right_output_dir = dst_root
            self._set_ui_state("processing_fwd")
            threading.Thread(
                target=self._run_dicom_only,
                args=(src_root, dst_root, dicom_tags, replace_text),
                daemon=True,
            ).start()
            return

        id_digits = int(self.id_digits.get())
        simple_text = self.simple_text.get()

        existing_map = None
        incremental = False
        new_id_template = None

        if mode == "simple":
            csv_path = Path(src_root) / MAPPING_CSV
            dst_exists = os.path.exists(dst_root)
            csv_exists = csv_path.exists()

            if not dst_exists and not csv_exists:
                # シナリオA: 通常全件処理
                pass
            elif not dst_exists and csv_exists:
                # シナリオB: CSV読込→新規ID確認ダイアログ
                existing_map = self._load_mapping_csv(csv_path)
                new_ids = self._find_new_ids(src_root, id_digits, existing_map)

                if new_ids:
                    max_num, num_width, template, ptype = \
                        self._detect_max_number(existing_map, simple_text)
                    if ptype == "numbered":
                        next_num_str = str(max_num + 1).zfill(num_width)
                        next_preview = template.replace("{NUM}", next_num_str)
                    else:
                        next_preview = f"{simple_text}_{max_num + 1:03d}"

                    dlg = NewIdAssignDialog(
                        self,
                        existing_count=len(existing_map),
                        new_count=len(new_ids),
                        next_preview=next_preview,
                        current_template=simple_text,
                    )
                    self.wait_window(dlg)

                    if dlg.result is None:
                        return
                    if dlg.result == "change":
                        new_id_template = dlg.new_template
                    # else: "continue" → 同パターン続番
                # new_ids が空でも既存マップは流用
            elif dst_exists and not csv_exists:
                # シナリオC: 対応表が見つからない → 全件再処理確認
                if not messagebox.askyesno(
                    "確認",
                    "対応表が見つかりません。\n"
                    "対応表モードで全件再処理しますか？"
                ):
                    return
            else:
                # シナリオD: 出力あり・CSVあり → 差分処理確認
                existing_map = self._load_mapping_csv(csv_path)
                new_ids = self._find_new_ids(src_root, id_digits, existing_map)
                info_parts = [f"既存対応表: {len(existing_map)} 件"]
                if new_ids:
                    info_parts.append(f"新規ID: {len(new_ids)} 件")
                info = "\n".join(info_parts)

                ans = messagebox.askyesnocancel(
                    "差分処理",
                    f"{info}\n\n"
                    "差分処理を行いますか？\n"
                    "「はい」→ 追加分のみ処理\n"
                    "「いいえ」→ 全件上書き"
                )
                if ans is None:
                    return
                if ans:
                    incremental = True
                else:
                    existing_map = None  # 全件上書き
        else:
            # Feistel モード: 従来の上書き確認
            if os.path.exists(dst_root):
                if not messagebox.askyesno(
                    "確認",
                    f"出力先が既に存在します:\n{dst_root}\n\n上書きしますか？"
                ):
                    return

        dicom_tags = {}
        if self.opt_dicom.get() and HAS_PYDICOM:
            for tag, var in self.tag_vars.items():
                if var.get():
                    dicom_tags[tag] = self.tag_entries[tag].get()

        prefix = self.prefix.get()

        self._save_current_settings()

        opt_rename = self.opt_rename.get()
        opt_text = self.opt_text.get()

        self.processing = True
        self.progress.set(0)
        self._right_output_dir = dst_root
        self._set_ui_state("processing_fwd")

        threading.Thread(
            target=self._run_anonymization,
            args=(src_root, dst_root, dicom_tags, id_digits, prefix,
                  mode, simple_text, opt_rename, opt_text),
            kwargs=dict(existing_map=existing_map,
                        incremental=incremental,
                        new_id_template=new_id_template,
                        single_id_filter=self._single_id_filter),
            daemon=True,
        ).start()

    def _start_processing_reverse(self, src_root: str):
        """匿名化解除処理開始 (鍵ID → 元ID) ※Feistelモードのみ"""
        if self.anon_mode.get() != "feistel":
            messagebox.showerror("エラー", "対応表モードでは匿名化解除できません")
            return

        if not self._check_password_strength():
            return

        try:
            dst_root = self._get_dst_root(src_root, "reverse")
        except ValueError as e:
            messagebox.showerror("エラー", str(e))
            return

        if os.path.exists(dst_root):
            if not messagebox.askyesno(
                "確認", f"出力先が既に存在します:\n{dst_root}\n\n上書きしますか？"
            ):
                return

        dicom_tags = {}
        if self.opt_dicom.get() and HAS_PYDICOM:
            for tag, var in self.tag_vars.items():
                if var.get():
                    dicom_tags[tag] = self.tag_entries[tag].get()

        id_digits = int(self.id_digits.get())
        prefix = self.prefix.get()

        self._save_current_settings()

        opt_rename = self.opt_rename.get()
        opt_text = self.opt_text.get()

        self.processing = True
        self.progress.set(0)
        self._left_output_dir = dst_root
        self._set_ui_state("processing_rev")

        threading.Thread(
            target=self._run_deanonymization,
            args=(src_root, dst_root, dicom_tags, id_digits, prefix,
                  opt_rename, opt_text),
            daemon=True,
        ).start()

    def _right_has_mapping(self) -> bool:
        """右ゾーンに選択されたフォルダに_対応表.csvが存在するか"""
        if not self._right_path:
            return False
        return (Path(self._right_path) / MAPPING_CSV).exists()

    # --------------------------------------------------------
    # 差分匿名化ヘルパー
    # --------------------------------------------------------

    def _load_mapping_csv(self, csv_path: Path) -> dict:
        """CSV読込 → {orig_id: anon_id}"""
        mapping = {}
        with open(csv_path, "r", encoding="utf-8-sig") as f:
            reader = csv.reader(f)
            next(reader)  # ヘッダー行スキップ
            for row in reader:
                if len(row) >= 2:
                    mapping[row[0]] = row[1]
        return mapping

    @staticmethod
    def _detect_max_number(existing_map: dict, simple_text: str):
        """CSVの匿名化IDから最大連番を検出。
        Returns: (max_num, num_width, template, pattern_type)
          pattern_type: "numbered" ({0000}パターン) / "suffix" (suffix_NNN)
        """
        anon_ids = list(existing_map.values())
        if not anon_ids:
            return (0, 4, simple_text, "numbered")

        # {0000} パターン検出
        num_match = re.search(r"\{(\d+)\}", simple_text)
        if num_match:
            num_width = len(num_match.group(1))
            template = (simple_text[:num_match.start()]
                        + "{NUM}"
                        + simple_text[num_match.end():])
            prefix_part = simple_text[:num_match.start()]
            suffix_part = simple_text[num_match.end():]
            max_num = 0
            for aid in anon_ids:
                if aid.startswith(prefix_part) and aid.endswith(suffix_part):
                    mid = aid[len(prefix_part):]
                    if suffix_part:
                        mid = mid[:-len(suffix_part)]
                    try:
                        max_num = max(max_num, int(mid))
                    except ValueError:
                        pass
            return (max_num, num_width, template, "numbered")

        # suffixパターン (tokumeika_002)
        max_num = 0
        for aid in anon_ids:
            m = re.search(r"_(\d+)$", aid)
            if m:
                max_num = max(max_num, int(m.group(1)))
        if max_num > 0:
            return (max_num, 3, simple_text, "suffix")

        # 1件のみで suffix なし → suffix パターンの max=1 として扱う
        return (1, 3, simple_text, "suffix")

    def _build_simple_ids(self, orig_ids, simple_text,
                          existing_map=None, new_id_template=None):
        """対応表モード用: orig_id → anon_id マッピング構築。

        orig_ids: マッピングしたい元IDのリスト (順序維持)
        Returns: {orig_id: anon_id}
        """
        unique_ids = {}
        if existing_map:
            unique_ids = dict(existing_map)
            active_text = new_id_template if new_id_template else simple_text
            max_num, num_width, template, ptype = \
                self._detect_max_number(existing_map, active_text)
            if new_id_template:
                nm = re.search(r"\{(\d+)\}", new_id_template)
                if nm:
                    num_width = len(nm.group(1))
                    template = (new_id_template[:nm.start()]
                                + "{NUM}" + new_id_template[nm.end():])
                    ptype = "numbered"
                    max_num = int(nm.group(1)) - 1
                else:
                    ptype = "suffix"
                    max_num = 0
            counter = max_num
            for oid in orig_ids:
                if oid not in unique_ids:
                    counter += 1
                    if ptype == "numbered":
                        unique_ids[oid] = template.replace(
                            "{NUM}", str(counter).zfill(num_width))
                    else:
                        unique_ids[oid] = f"{active_text}_{counter:03d}"
            new_count = counter - max_num
            if new_count > 0:
                self._log(f"新規ID割当: {new_count} 件 (続番 {max_num + 1}〜)")
        else:
            num_match = re.search(r"\{(\d+)\}", simple_text)
            if num_match:
                start_num = int(num_match.group(1))
                num_width = len(num_match.group(1))
                template = (simple_text[:num_match.start()]
                            + "{NUM}" + simple_text[num_match.end():])
                counter = 0
                for oid in orig_ids:
                    if oid not in unique_ids:
                        num_str = str(start_num + counter).zfill(num_width)
                        unique_ids[oid] = template.replace("{NUM}", num_str)
                        counter += 1
            else:
                counter = 0
                for oid in orig_ids:
                    if oid not in unique_ids:
                        counter += 1
                        if counter == 1:
                            unique_ids[oid] = simple_text
                        else:
                            unique_ids[oid] = f"{simple_text}_{counter:03d}"
        return unique_ids

    def _save_mapping_csv(self, src_root, unique_ids):
        """対応表CSVを保存/上書き"""
        csv_path = Path(src_root) / MAPPING_CSV
        with open(csv_path, "w", encoding="utf-8-sig", newline="") as f:
            writer = csv.writer(f)
            writer.writerow(["元ID", "匿名化ID"])
            for orig, anon in unique_ids.items():
                writer.writerow([orig, anon])
        self._log(f"対応表保存: {csv_path} ({len(unique_ids)} 件)")

    def _find_new_ids(self, src_root: str, id_digits: int,
                      existing_map: dict) -> list:
        """src_root内のID桁フォルダのうち、existing_mapに無いものをリストアップ"""
        pattern = re.compile(r"^\d{" + str(id_digits) + r"}(?!\d)")
        new_ids = []
        for d in sorted(Path(src_root).iterdir()):
            if d.is_dir() and pattern.match(d.name):
                orig_id = d.name[:id_digits]
                if orig_id not in existing_map and orig_id not in new_ids:
                    new_ids.append(orig_id)
        return new_ids

    def _start_processing_reverse_simple(self, src_root: str, csv_path: Path):
        """対応表モードの匿名化解除 (CSV対応表ベース)"""
        try:
            dst_root = self._get_dst_root(src_root, "reverse")
        except ValueError as e:
            messagebox.showerror("エラー", str(e))
            return

        if os.path.exists(dst_root):
            if not messagebox.askyesno(
                "確認", f"出力先が既に存在します:\n{dst_root}\n\n上書きしますか？"
            ):
                return

        opt_rename = self.opt_rename.get()
        opt_text = self.opt_text.get()

        self._save_current_settings()
        self.processing = True
        self.progress.set(0)
        self._left_output_dir = dst_root
        self._set_ui_state("processing_rev")

        threading.Thread(
            target=self._run_deanonymization_simple,
            args=(src_root, dst_root, csv_path, opt_rename, opt_text),
            daemon=True,
        ).start()

    def _run_deanonymization_simple(self, src_root, dst_root, csv_path,
                                     opt_rename=True, opt_text=True):
        """対応表モード匿名化解除ワーカー (CSV対応表ベース)"""
        try:
            self._log(f"匿名化解除開始 (CSV): {src_root}")

            # CSV読み込み → 逆マッピング {anon_id: orig_id}
            reverse_map = {}
            with open(csv_path, "r", encoding="utf-8-sig") as f:
                reader = csv.reader(f)
                next(reader)  # ヘッダー行スキップ
                for row in reader:
                    if len(row) >= 2:
                        orig_id, anon_id = row[0], row[1]
                        reverse_map[anon_id] = orig_id

            if not reverse_map:
                msg = "対応表が空です"
                self._log(msg)
                self._thread_call(lambda: messagebox.showerror("エラー", msg))
                self._thread_call(lambda: self._set_ui_state("idle"))
                return

            self._log(f"対応表: {len(reverse_map)} エントリ")

            # 匿名化IDに一致するフォルダを検出
            subdirs = sorted(
                d for d in Path(src_root).iterdir()
                if d.is_dir() and d.name != "__pycache__"
            )

            matched_dirs = []
            for dp in subdirs:
                for anon_id in reverse_map:
                    if dp.name.startswith(anon_id):
                        matched_dirs.append((dp, anon_id, reverse_map[anon_id]))
                        break

            if not matched_dirs:
                msg = "対応表に一致するフォルダが見つかりません"
                self._log(msg)
                self._thread_call(lambda: messagebox.showerror("エラー", msg))
                self._thread_call(lambda: self._set_ui_state("idle"))
                return

            os.makedirs(dst_root, exist_ok=True)
            total = sum(
                1 for dp, _, _ in matched_dirs
                for f in dp.rglob("*") if f.is_file()
            )
            self._log(f"検出: {len(matched_dirs)} フォルダ / {total} ファイル")
            processed = 0

            for dp, anon_id, orig_id in matched_dirs:
                suffix = dp.name[len(anon_id):]
                orig_name = orig_id + suffix
                orig_dir = Path(dst_root) / orig_name
                os.makedirs(orig_dir, exist_ok=True)
                self._log(f"{dp.name} -> {orig_name}")

                for fp in sorted(dp.rglob("*")):
                    if not fp.is_file():
                        continue
                    if fp.name == MAPPING_CSV:
                        continue  # 対応表自体はスキップ

                    rel = fp.relative_to(dp)
                    if opt_rename:
                        new_rel = Path(
                            *(p.replace(anon_id, orig_id) for p in rel.parts)
                        )
                    else:
                        new_rel = rel
                    dst = orig_dir / new_rel
                    os.makedirs(dst.parent, exist_ok=True)
                    ext = fp.suffix.lower()

                    if opt_text and ext in TEXT_EXTS:
                        self._process_text(fp, dst, anon_id, orig_id, rel)
                    elif opt_text and ext in RICH_EXTS:
                        self._process_rich_text(
                            fp, dst, anon_id, orig_id, rel, ext
                        )
                    elif opt_text and ext == XLSX_EXT and HAS_OPENPYXL:
                        self._process_xlsx(fp, dst, anon_id, orig_id, rel)
                    elif opt_text and ext in OOXML_EXTS:
                        self._process_ooxml(
                            fp, dst, anon_id, orig_id, rel, ext
                        )
                    else:
                        shutil.copy2(str(fp), str(dst))

                    processed += 1
                    if total > 0:
                        self._thread_call(
                            lambda p=processed / total: self.progress.set(p)
                        )
                    self._thread_call(
                        lambda p=processed, t=total:
                            self.status_label.configure(
                                text=f"処理中... {p}/{t}"
                            )
                    )

            summary = f"{len(matched_dirs)} フォルダ / {processed} ファイル"
            self._log(f"匿名化解除完了: {summary} → {dst_root}")
            self.last_output_dir = dst_root
            self._left_output_dir = dst_root
            self._thread_call(
                lambda: self._on_reverse_complete(summary, dst_root)
            )

        except Exception as e:
            self._log(f"エラー: {e}")
            self._thread_call(
                lambda err=str(e): messagebox.showerror("エラー", err)
            )
            self._thread_call(lambda: self._set_ui_state("idle"))
        finally:
            self.processing = False

    def _set_ui_state(self, state: str):
        """全ゾーンの外観を状態に応じて一括更新"""
        self._ui_state = state
        mode = self.anon_mode.get()
        is_feistel = mode == "feistel"

        # デフォルト値
        lb, lbg = CLR_LEFT_BORDER, CLR_LEFT_BG
        li, lt, ls = ICON_LOCK_OPEN, "元データ", "クリックして選択"
        rb, rbg = CLR_RIGHT_BORDER, CLR_RIGHT_BG
        ri, rt, rs = ICON_LOCK_CLOSED, "匿名化データ", "クリックして選択"
        ar_st, ar_fg = "disabled", CLR_ARROW_DISABLED
        al_st, al_fg = "disabled", CLR_ARROW_DISABLED

        if state == "left_selected":
            lb, lbg = CLR_ACCENT, CLR_ZONE_SELECTED_BG
            if self._single_id_filter:
                lt = self._single_id_filter + " (単独)"
            else:
                lt = Path(self._left_path).name
            ls = "選択済み"
            ar_st, ar_fg = "normal", CLR_ACCENT

        elif state == "right_selected":
            rb, rbg = CLR_ACCENT, CLR_ZONE_SELECTED_BG
            rt = Path(self._right_path).name
            rs = "選択済み"
            can_reverse = is_feistel or (mode == "simple" and self._right_has_mapping())
            if can_reverse:
                al_st, al_fg = "normal", CLR_ACCENT

        elif state == "processing_fwd":
            lb = CLR_PROCESSING
            li, lt = "\u23F3", Path(self._left_path).name
            ls = "処理中..."
            rb = CLR_PROCESSING
            ri, rt, rs = "\u23F3", "出力先", "処理中..."
            ar_fg = CLR_PROCESSING

        elif state == "processing_rev":
            lb = CLR_PROCESSING
            li, lt, ls = "\u23F3", "出力先", "処理中..."
            rb = CLR_PROCESSING
            ri, rt = "\u23F3", Path(self._right_path).name
            rs = "処理中..."
            al_fg = CLR_PROCESSING

        elif state == "done_forward":
            lt = Path(self._left_path).name
            ls = ""
            rb, rbg = CLR_SUCCESS, CLR_DONE_BG
            ri, rt, rs = "\u2705", "完了!", "クリックで開く"

        elif state == "done_reverse":
            lb, lbg = CLR_SUCCESS, CLR_DONE_BG
            li, lt, ls = "\u2705", "完了!", "クリックで開く"
            rt = Path(self._right_path).name
            rs = ""

        # --- フルビュー適用 ---
        self.left_zone.configure(border_color=lb, fg_color=lbg)
        self.left_icon.configure(text=li)
        self.left_text.configure(text=lt)
        self.left_sub.configure(text=ls)

        self.right_zone.configure(border_color=rb, fg_color=rbg)
        self.right_icon.configure(text=ri)
        self.right_text.configure(text=rt)
        self.right_sub.configure(text=rs)

        if ar_st == "normal":
            self.arrow_right_btn.configure(
                state="normal", fg_color=ar_fg, text_color="white",
                hover=True, hover_color=("#2563EB", "#3B82F6"))
        else:
            self.arrow_right_btn.configure(
                state="disabled", fg_color=ar_fg,
                text_color=("gray", "gray"), hover=False)

        if al_st == "normal":
            self.arrow_left_btn.configure(
                state="normal", fg_color=al_fg, text_color="white",
                hover=True, hover_color=("#2563EB", "#3B82F6"))
        else:
            self.arrow_left_btn.configure(
                state="disabled", fg_color=al_fg,
                text_color=("gray", "gray"), hover=False)

        # --- コンパクトビュー適用 ---
        self._c_left_zone.configure(border_color=lb, fg_color=lbg)
        self._c_left_icon.configure(text=li)
        self._c_left_text.configure(text=lt)
        self._c_left_sub.configure(text=ls)

        self._c_right_zone.configure(border_color=rb, fg_color=rbg)
        self._c_right_icon.configure(text=ri)
        self._c_right_text.configure(text=rt)
        self._c_right_sub.configure(text=rs)

        if ar_st == "normal":
            self._c_arrow_right_btn.configure(
                state="normal", fg_color=ar_fg, text_color="white",
                hover=True, hover_color=("#2563EB", "#3B82F6"))
        else:
            self._c_arrow_right_btn.configure(
                state="disabled", fg_color=ar_fg,
                text_color=("gray", "gray"), hover=False)

        if al_st == "normal":
            self._c_arrow_left_btn.configure(
                state="normal", fg_color=al_fg, text_color="white",
                hover=True, hover_color=("#2563EB", "#3B82F6"))
        else:
            self._c_arrow_left_btn.configure(
                state="disabled", fg_color=al_fg,
                text_color=("gray", "gray"), hover=False)

    # --------------------------------------------------------
    # メイン処理 (ワーカースレッド)
    # --------------------------------------------------------

    def _run_anonymization(self, src_root, dst_root, dicom_tags_template,
                           id_digits=7, prefix="K", mode="feistel", simple_text="tokumeika",
                           opt_rename=True, opt_text=True,
                           existing_map=None, incremental=False,
                           new_id_template=None, single_id_filter=None):
        try:
            self._log(f"開始: {src_root}")
            self._log(f"設定: {id_digits}桁, モード={mode}, 接頭辞={prefix}")
            if single_id_filter:
                self._log(f"単独IDフォルダ: {single_id_filter}")
            if existing_map:
                self._log(f"既存対応表: {len(existing_map)} 件")
            if incremental:
                self._log("差分処理モード")

            pattern = re.compile(r"^\d{" + str(id_digits) + r"}(?!\d)")
            subdirs = sorted(
                d for d in Path(src_root).iterdir()
                if d.is_dir() and pattern.match(d.name)
            )

            if single_id_filter:
                subdirs = [d for d in subdirs if d.name == single_id_filter]

            # --- サブフォルダなし → 親DIR内のDICOM or CSV/Excel を検出 ---
            if not subdirs:
                all_parent = sorted(
                    f for f in Path(src_root).iterdir() if f.is_file())
                p_dicoms = ([f for f in all_parent if self._is_dicom(f)]
                            if HAS_PYDICOM else [])
                p_tabular = [
                    f for f in all_parent
                    if f.suffix.lower() in ('.csv', '.tsv', '.xlsx')
                    and f.name != MAPPING_CSV
                ]
                if p_dicoms:
                    self._run_anon_flat_dicom(
                        src_root, dst_root, p_dicoms, p_tabular,
                        dicom_tags_template, id_digits, prefix,
                        mode, simple_text, opt_rename,
                        existing_map, new_id_template)
                    return
                elif p_tabular:
                    self._run_anon_flat_tabular(
                        src_root, dst_root, p_tabular,
                        id_digits, prefix, mode, simple_text,
                        existing_map, new_id_template)
                    return
                else:
                    msg = f"{id_digits}桁IDフォルダもDICOM/CSV/Excelも見つかりません"
                    self._log(msg)
                    self._thread_call(
                        lambda: messagebox.showerror("エラー", msg))
                    self._thread_call(lambda: self._set_ui_state("idle"))
                    return

            os.makedirs(dst_root, exist_ok=True)

            total = sum(1 for d in subdirs for f in d.rglob("*") if f.is_file())
            self._log(f"検出: {len(subdirs)} フォルダ / {total} ファイル")

            processed = 0
            skipped = 0

            # 対応表モード: 共通ヘルパーでマッピング構築
            unique_ids = {}
            if mode == "simple":
                orig_id_list = []
                for dp in subdirs:
                    oid = dp.name[:id_digits]
                    if oid not in orig_id_list:
                        orig_id_list.append(oid)
                unique_ids = self._build_simple_ids(
                    orig_id_list, simple_text, existing_map, new_id_template)

            if mode == "simple" and unique_ids:
                self._save_mapping_csv(src_root, unique_ids)

            for dp in subdirs:
                orig_id = dp.name[:id_digits]
                suffix = dp.name[id_digits:]

                if mode == "feistel":
                    anon_id = protect_id(orig_id, self.key, id_digits, prefix)
                else:
                    anon_id = unique_ids[orig_id]

                anon_name = anon_id + suffix

                anon_dir = Path(dst_root) / anon_name
                os.makedirs(anon_dir, exist_ok=True)

                self._log(f"{dp.name} -> {anon_name}")

                # {id} → 匿名化 ID に置換
                tags = {
                    t: v.replace("{id}", anon_id)
                    for t, v in dicom_tags_template.items()
                }

                for fp in sorted(dp.rglob("*")):
                    if not fp.is_file():
                        continue

                    rel = fp.relative_to(dp)

                    if opt_rename:
                        new_rel = Path(*(p.replace(orig_id, anon_id) for p in rel.parts))
                    else:
                        new_rel = rel

                    dst = anon_dir / new_rel

                    # 差分処理: 既存ファイルはスキップ
                    if incremental and dst.exists():
                        skipped += 1
                        processed += 1
                        if total > 0:
                            self._thread_call(lambda p=processed / total: self.progress.set(p))
                        self._thread_call(lambda p=processed, t=total:
                                   self.status_label.configure(text=f"処理中... {p}/{t}"))
                        continue

                    os.makedirs(dst.parent, exist_ok=True)

                    ext = fp.suffix.lower()

                    if tags and self._is_dicom(fp):
                        ok, msg = self._anon_dicom(str(fp), str(dst), tags)
                        if ok:
                            self._log(f"  [DICOM]        {rel}")
                        else:
                            self._log(f"  [DICOM ERROR]  {rel}: {msg}")

                    elif opt_text and ext in TEXT_EXTS:
                        self._process_text(fp, dst, orig_id, anon_id, rel)

                    elif opt_text and ext in RICH_EXTS:
                        self._process_rich_text(fp, dst, orig_id, anon_id, rel, ext)

                    elif opt_text and ext == XLSX_EXT and HAS_OPENPYXL:
                        self._process_xlsx(fp, dst, orig_id, anon_id, rel)

                    elif opt_text and ext in OOXML_EXTS:
                        self._process_ooxml(fp, dst, orig_id, anon_id, rel, ext)

                    else:
                        shutil.copy2(str(fp), str(dst))
                        if str(rel) != str(new_rel):
                            self._log(f"  [name only]    {rel} -> {new_rel}")
                        else:
                            self._log(f"  [copy]         {rel}")

                    processed += 1
                    if total > 0:
                        self._thread_call(lambda p=processed / total: self.progress.set(p))
                    self._thread_call(lambda p=processed, t=total:
                               self.status_label.configure(text=f"処理中... {p}/{t}"))

            # --- 親DIR直下の CSV/Excel を匿名化 ---
            parent_anon_count = 0
            if opt_text:
                parent_files = sorted(
                    f for f in Path(src_root).iterdir()
                    if f.is_file()
                    and f.suffix.lower() in ('.csv', '.tsv', '.xlsx')
                    and f.name != MAPPING_CSV
                )
                if parent_files:
                    id_map = {}
                    for dp in subdirs:
                        oid = dp.name[:id_digits]
                        if mode == "feistel":
                            id_map[oid] = protect_id(
                                oid, self.key, id_digits, prefix)
                        elif oid in unique_ids:
                            id_map[oid] = unique_ids[oid]
                    known_set = set(id_map.keys())

                    self._log(f"親DIR: {len(parent_files)} ファイル検出")
                    for pf in parent_files:
                        dst_pf = Path(dst_root) / pf.name
                        try:
                            ext_p = pf.suffix.lower()
                            result = None
                            if ext_p in ('.csv', '.tsv'):
                                result = self._anon_parent_csv(
                                    pf, dst_pf, id_map, known_set,
                                    id_digits, prefix, mode)
                            elif ext_p == '.xlsx' and HAS_OPENPYXL:
                                result = self._anon_parent_xlsx(
                                    pf, dst_pf, id_map, known_set,
                                    id_digits, prefix, mode)
                            if result:
                                self._log(
                                    f"  [親DIR]  {pf.name}: {result}")
                                parent_anon_count += 1
                            else:
                                shutil.copy2(str(pf), str(dst_pf))
                                self._log(
                                    f"  [親DIR]  {pf.name}: コピー")
                        except Exception as e:
                            shutil.copy2(str(pf), str(dst_pf))
                            self._log(
                                f"  [親DIR]  {pf.name}: エラー ({e})")

            if incremental:
                actual = processed - skipped
                summary = f"{len(subdirs)} フォルダ / {actual} 処理 / {skipped} スキップ"
            else:
                summary = f"{len(subdirs)} フォルダ / {processed} ファイル"
            if parent_anon_count:
                summary += f" / 親DIR {parent_anon_count} ファイル匿名化"
            self._log(f"完了: {summary} → {dst_root}")

            self.last_output_dir = dst_root
            self._right_output_dir = dst_root
            self._thread_call(lambda: self._on_forward_complete(summary, dst_root))

        except Exception as e:
            self._log(f"エラー: {e}")
            self._thread_call(lambda err=str(e): messagebox.showerror("エラー", err))
            self._thread_call(lambda: self._set_ui_state("idle"))

        finally:
            self.processing = False

    def _run_deanonymization(self, src_root, dst_root, dicom_tags_template,
                              id_digits=7, prefix="K",
                              opt_rename=True, opt_text=True):
        """匿名化解除ワーカースレッド (鍵ID → 元ID)"""
        try:
            self._log(f"匿名化解除開始: {src_root}")
            self._log(f"設定: {id_digits}桁, 接頭辞={prefix}")

            _, out_digits = get_cipher_params(id_digits)
            pattern = re.compile(
                r"^" + re.escape(prefix) + r"\d{" + str(out_digits) + r"}(?!\d)"
            )

            subdirs = sorted(
                d for d in Path(src_root).iterdir()
                if d.is_dir() and pattern.match(d.name)
            )

            if not subdirs:
                msg = f"{prefix}+{out_digits}桁IDで始まるフォルダが見つかりません"
                self._log(msg)
                self._thread_call(lambda: messagebox.showerror("エラー", msg))
                self._thread_call(lambda: self._set_ui_state("idle"))
                return

            os.makedirs(dst_root, exist_ok=True)

            total = sum(1 for d in subdirs for f in d.rglob("*") if f.is_file())
            self._log(f"検出: {len(subdirs)} フォルダ / {total} ファイル")

            processed = 0
            prefix_len = len(prefix)

            for dp in subdirs:
                # 匿名化ID抽出 (prefix + out_digits桁)
                anon_id = dp.name[:prefix_len + out_digits]
                suffix = dp.name[prefix_len + out_digits:]

                # Feistel逆変換で元IDを復元
                orig_id = unprotect_id(anon_id, self.key, id_digits, prefix)
                orig_name = orig_id + suffix

                orig_dir = Path(dst_root) / orig_name
                os.makedirs(orig_dir, exist_ok=True)

                self._log(f"{dp.name} -> {orig_name}")

                # {id} → 元ID に置換 (DICOM用)
                tags = {
                    t: v.replace("{id}", orig_id)
                    for t, v in dicom_tags_template.items()
                }

                for fp in sorted(dp.rglob("*")):
                    if not fp.is_file():
                        continue

                    rel = fp.relative_to(dp)

                    if opt_rename:
                        new_rel = Path(*(p.replace(anon_id, orig_id) for p in rel.parts))
                    else:
                        new_rel = rel

                    dst = orig_dir / new_rel
                    os.makedirs(dst.parent, exist_ok=True)

                    ext = fp.suffix.lower()

                    if tags and self._is_dicom(fp):
                        ok, msg = self._anon_dicom(str(fp), str(dst), tags)
                        if ok:
                            self._log(f"  [DICOM]        {rel}")
                        else:
                            self._log(f"  [DICOM ERROR]  {rel}: {msg}")

                    elif opt_text and ext in TEXT_EXTS:
                        self._process_text(fp, dst, anon_id, orig_id, rel)

                    elif opt_text and ext in RICH_EXTS:
                        self._process_rich_text(fp, dst, anon_id, orig_id, rel, ext)

                    elif opt_text and ext == XLSX_EXT and HAS_OPENPYXL:
                        self._process_xlsx(fp, dst, anon_id, orig_id, rel)

                    elif opt_text and ext in OOXML_EXTS:
                        self._process_ooxml(fp, dst, anon_id, orig_id, rel, ext)

                    else:
                        shutil.copy2(str(fp), str(dst))
                        if str(rel) != str(new_rel):
                            self._log(f"  [name only]    {rel} -> {new_rel}")
                        else:
                            self._log(f"  [copy]         {rel}")

                    processed += 1
                    if total > 0:
                        self._thread_call(lambda p=processed / total: self.progress.set(p))
                    self._thread_call(lambda p=processed, t=total:
                               self.status_label.configure(text=f"匿名化解除中... {p}/{t}"))

            summary = f"{len(subdirs)} フォルダ / {processed} ファイル"
            self._log(f"匿名化解除完了: {summary} → {dst_root}")

            self.last_output_dir = dst_root
            self._left_output_dir = dst_root
            self._thread_call(lambda: self._on_reverse_complete(summary, dst_root))

        except Exception as e:
            self._log(f"エラー: {e}")
            self._thread_call(lambda err=str(e): messagebox.showerror("エラー", err))
            self._thread_call(lambda: self._set_ui_state("idle"))

        finally:
            self.processing = False

    # --------------------------------------------------------
    # シナリオB: 親DIR直下のDICOM (feistel/simple)
    # --------------------------------------------------------

    def _run_anon_flat_dicom(self, src_root, dst_root, dicom_files,
                             tabular_files, dicom_tags_template,
                             id_digits, prefix, mode, simple_text,
                             opt_rename, existing_map, new_id_template):
        """親DIR直下のDICOMをfeistel/simpleモードで匿名化。"""
        try:
            self._log(f"親DIR DICOM匿名化: {len(dicom_files)} ファイル")

            # 1) PatientID 収集
            file_pids = {}   # filepath -> patient_id
            unique_pids = []
            for fp in dicom_files:
                try:
                    ds = pydicom.dcmread(fp, stop_before_pixels=True)
                    pid = str(getattr(ds, 'PatientID', '')).strip()
                    if pid:
                        # 0埋め補正
                        if pid.isdigit() and len(pid) < id_digits:
                            pid = pid.zfill(id_digits)
                        file_pids[fp] = pid
                        if pid not in unique_pids:
                            unique_pids.append(pid)
                except Exception:
                    pass

            if not unique_pids:
                msg = "DICOMからPatientIDを取得できません"
                self._log(msg)
                self._thread_call(
                    lambda: messagebox.showerror("エラー", msg))
                self._thread_call(lambda: self._set_ui_state("idle"))
                return

            self._log(f"検出: {len(unique_pids)} ユニークID")

            # 2) IDマッピング構築
            if mode == "feistel":
                id_map = {}
                for pid in unique_pids:
                    try:
                        id_map[pid] = protect_id(
                            pid, self.key, id_digits, prefix)
                    except Exception:
                        id_map[pid] = prefix + pid
            else:
                id_map = self._build_simple_ids(
                    unique_pids, simple_text,
                    existing_map, new_id_template)

            # 3) 対応表保存
            if mode == "simple" and id_map:
                self._save_mapping_csv(src_root, id_map)

            # 4) DICOMタグテンプレート準備
            os.makedirs(dst_root, exist_ok=True)

            # 5) ファイル処理 — リネーム計画
            rename_plan = []
            for fp in dicom_files:
                rel = fp.relative_to(src_root)
                pid = file_pids.get(fp, "")
                anon_id = id_map.get(pid, "")

                if pid and anon_id and opt_rename:
                    new_parts = [p.replace(pid, anon_id) for p in rel.parts]
                    new_rel = Path(*new_parts)
                else:
                    new_rel = rel
                dst = Path(dst_root) / new_rel
                rename_plan.append((fp, dst, pid, anon_id))

            # 衝突回避
            dst_groups = {}
            for i, (_, dst, _, _) in enumerate(rename_plan):
                dst_groups.setdefault(str(dst), []).append(i)
            for indices in dst_groups.values():
                if len(indices) > 1:
                    for seq, idx in enumerate(indices):
                        fp, dst, pid, aid = rename_plan[idx]
                        rename_plan[idx] = (
                            fp,
                            dst.parent / f"{dst.stem}_{seq}{dst.suffix}",
                            pid, aid)

            # 6) 実行
            total = len(rename_plan)
            processed = 0
            errors = 0
            for fp, dst, pid, anon_id in rename_plan:
                rel = fp.relative_to(src_root)
                dst_rel = dst.relative_to(dst_root)
                os.makedirs(dst.parent, exist_ok=True)

                if anon_id:
                    tags = {t: v.replace("{id}", anon_id)
                            for t, v in dicom_tags_template.items()}
                else:
                    tags = dicom_tags_template

                ok, msg = self._anon_dicom(str(fp), str(dst), tags)
                if ok:
                    if str(rel) != str(dst_rel):
                        self._log(f"  [DICOM] {rel} -> {dst_rel}")
                    else:
                        self._log(f"  [DICOM] {rel}")
                else:
                    self._log(f"  [ERROR] {rel}: {msg}")
                    errors += 1

                processed += 1
                if total > 0:
                    self._thread_call(
                        lambda p=processed / total: self.progress.set(p))
                self._thread_call(lambda p=processed, t=total:
                    self.status_label.configure(text=f"処理中... {p}/{t}"))

            # 7) 親DIR内CSV/Excelも処理
            parent_anon = 0
            if tabular_files:
                known_set = set(id_map.keys())
                self._log(f"親DIR CSV/Excel: {len(tabular_files)} ファイル")
                for pf in tabular_files:
                    dst_pf = Path(dst_root) / pf.name
                    try:
                        ext = pf.suffix.lower()
                        result = None
                        if ext in ('.csv', '.tsv'):
                            result = self._anon_parent_csv(
                                pf, dst_pf, id_map, known_set,
                                id_digits, prefix, mode)
                        elif ext == '.xlsx' and HAS_OPENPYXL:
                            result = self._anon_parent_xlsx(
                                pf, dst_pf, id_map, known_set,
                                id_digits, prefix, mode)
                        if result:
                            self._log(f"  [親DIR] {pf.name}: {result}")
                            parent_anon += 1
                        else:
                            shutil.copy2(str(pf), str(dst_pf))
                            self._log(f"  [親DIR] {pf.name}: コピー")
                    except Exception as e:
                        shutil.copy2(str(pf), str(dst_pf))
                        self._log(f"  [親DIR] {pf.name}: エラー ({e})")

            summary = f"{processed} DICOM / {len(unique_pids)} ID"
            if errors:
                summary += f" / {errors} エラー"
            if parent_anon:
                summary += f" / 親DIR {parent_anon} ファイル匿名化"
            self._log(f"完了: {summary} → {dst_root}")

            self.last_output_dir = dst_root
            self._right_output_dir = dst_root
            self._thread_call(
                lambda: self._on_forward_complete(summary, dst_root))
        except Exception as e:
            self._log(f"エラー: {e}")
            self._thread_call(
                lambda err=str(e): messagebox.showerror("エラー", err))
            self._thread_call(lambda: self._set_ui_state("idle"))
        finally:
            self.processing = False

    # --------------------------------------------------------
    # シナリオC: 親DIR直下のCSV/Excelのみ (feistel/simple)
    # --------------------------------------------------------

    def _run_anon_flat_tabular(self, src_root, dst_root, tabular_files,
                               id_digits, prefix, mode, simple_text,
                               existing_map, new_id_template):
        """親DIR直下のCSV/Excelのみをfeistel/simpleモードで匿名化。"""
        try:
            self._log(f"親DIR CSV/Excel匿名化: {len(tabular_files)} ファイル")

            # 1) 全ファイルを先読みしてIDを収集
            all_unique_ids = []
            file_scan = []   # [(path, headers, data_rows)]

            for pf in tabular_files:
                ext = pf.suffix.lower()
                try:
                    if ext in ('.csv', '.tsv'):
                        delim = '\t' if ext == '.tsv' else ','
                        rows = None
                        for enc in ("utf-8", "utf-8-sig", "cp932"):
                            try:
                                with open(pf, 'r', encoding=enc,
                                          newline='') as f:
                                    rows = list(csv.reader(f, delimiter=delim))
                                break
                            except (UnicodeDecodeError, UnicodeError):
                                continue
                        if rows and len(rows) >= 2:
                            file_scan.append((pf, rows[0], rows[1:]))
                    elif ext == '.xlsx' and HAS_OPENPYXL:
                        wb = openpyxl.load_workbook(str(pf), read_only=True)
                        for ws in wb.worksheets:
                            headers = []
                            data_rows = []
                            for i, row in enumerate(ws.iter_rows(
                                    values_only=True)):
                                vals = [str(v) if v is not None else ""
                                        for v in row]
                                if i == 0:
                                    headers = vals
                                else:
                                    data_rows.append(vals)
                            if headers and data_rows:
                                file_scan.append(
                                    (pf, headers, data_rows))
                        wb.close()
                except Exception as e:
                    self._log(f"  先読みエラー {pf.name}: {e}")

            # IDを検出 (既知IDなし → フォールバック桁数パターン)
            known_set = set(existing_map.keys()) if existing_map else set()
            for _, headers, data_rows in file_scan:
                id_cols, _ = self._detect_columns(
                    headers, data_rows, known_set, id_digits)
                for ic in id_cols:
                    for row in data_rows:
                        if ic < len(row):
                            v = str(row[ic]).strip()
                            if v.isdigit():
                                v = v.zfill(id_digits)
                                if len(v) == id_digits:
                                    if v not in all_unique_ids:
                                        all_unique_ids.append(v)
                            elif v and v not in all_unique_ids:
                                all_unique_ids.append(v)

            if not all_unique_ids:
                msg = "CSV/ExcelからIDを検出できません"
                self._log(msg)
                self._thread_call(
                    lambda: messagebox.showerror("エラー", msg))
                self._thread_call(lambda: self._set_ui_state("idle"))
                return

            self._log(f"検出: {len(all_unique_ids)} ユニークID")

            # 2) IDマッピング構築
            if mode == "feistel":
                id_map = {}
                for uid in all_unique_ids:
                    try:
                        id_map[uid] = protect_id(
                            uid, self.key, id_digits, prefix)
                    except Exception:
                        id_map[uid] = prefix + uid
            else:
                id_map = self._build_simple_ids(
                    all_unique_ids, simple_text,
                    existing_map, new_id_template)

            # 3) 対応表保存
            if mode == "simple" and id_map:
                self._save_mapping_csv(src_root, id_map)

            # 4) ファイル処理
            os.makedirs(dst_root, exist_ok=True)
            known_set = set(id_map.keys())
            total = len(tabular_files)
            processed_count = 0

            for pf in tabular_files:
                dst_pf = Path(dst_root) / pf.name
                try:
                    ext = pf.suffix.lower()
                    result = None
                    if ext in ('.csv', '.tsv'):
                        result = self._anon_parent_csv(
                            pf, dst_pf, id_map, known_set,
                            id_digits, prefix, mode)
                    elif ext == '.xlsx' and HAS_OPENPYXL:
                        result = self._anon_parent_xlsx(
                            pf, dst_pf, id_map, known_set,
                            id_digits, prefix, mode)
                    if result:
                        self._log(f"  {pf.name}: {result}")
                        processed_count += 1
                    else:
                        shutil.copy2(str(pf), str(dst_pf))
                        self._log(f"  {pf.name}: ID列なし → コピー")
                except Exception as e:
                    shutil.copy2(str(pf), str(dst_pf))
                    self._log(f"  {pf.name}: エラー ({e})")

                self._thread_call(
                    lambda p=(tabular_files.index(pf) + 1) / total:
                    self.progress.set(p))

            summary = (f"{processed_count}/{total} ファイル匿名化"
                       f" / {len(all_unique_ids)} ID")
            self._log(f"完了: {summary} → {dst_root}")

            self.last_output_dir = dst_root
            self._right_output_dir = dst_root
            self._thread_call(
                lambda: self._on_forward_complete(summary, dst_root))
        except Exception as e:
            self._log(f"エラー: {e}")
            self._thread_call(
                lambda err=str(e): messagebox.showerror("エラー", err))
            self._thread_call(lambda: self._set_ui_state("idle"))
        finally:
            self.processing = False

    # --------------------------------------------------------
    # DICOMタグのみモード専用ワーカー
    # --------------------------------------------------------

    def _run_dicom_only(self, src_root, dst_root, dicom_tags_template, replace_text):
        """DICOMタグ専用匿名化ワーカー（タグ書換 + リネーム）"""
        try:
            self._log(f"DICOMタグ専用匿名化開始: {src_root}")
            self._log(f"置換テキスト: {replace_text}")

            # src_root以下の全ファイルを再帰走査
            all_files = sorted(f for f in Path(src_root).rglob("*") if f.is_file())

            # DICOMファイルを検出
            dicom_files = [f for f in all_files if self._is_dicom(f)]
            non_dicom_count = len(all_files) - len(dicom_files)

            if not dicom_files:
                msg = "DICOMファイルが見つかりません"
                self._log(msg)
                self._thread_call(lambda: messagebox.showerror("エラー", msg))
                self._thread_call(lambda: self._set_ui_state("idle"))
                return

            self._log(f"検出: {len(dicom_files)} DICOMファイル / {non_dicom_count} 非DICOM (スキップ)")

            # タグ内 {id} → replace_text に置換
            tags = {t: v.replace("{id}", replace_text) for t, v in dicom_tags_template.items()}

            # --- 1) 各DICOMからPatientIDを読み取り、リネーム先を決定 ---
            rename_plan = []  # [(src_path, dst_path, orig_id)]
            for fp in dicom_files:
                rel = fp.relative_to(src_root)
                orig_id = ""
                try:
                    ds = pydicom.dcmread(fp, stop_before_pixels=True)
                    orig_id = str(getattr(ds, "PatientID", "")).strip()
                except Exception:
                    pass

                if orig_id:
                    new_parts = [part.replace(orig_id, replace_text) for part in rel.parts]
                    new_rel = Path(*new_parts)
                else:
                    new_rel = rel

                dst = Path(dst_root) / new_rel
                rename_plan.append((fp, dst, orig_id))

            # --- 2) 衝突検出: 同じ出力先が複数ある場合だけ連番を付与 ---
            dst_groups = {}
            for i, (_, dst, _) in enumerate(rename_plan):
                key = str(dst)
                dst_groups.setdefault(key, []).append(i)

            for dst_key, indices in dst_groups.items():
                if len(indices) > 1:
                    for seq, idx in enumerate(indices):
                        fp, dst, orig_id = rename_plan[idx]
                        new_dst = dst.parent / f"{dst.stem}_{seq}{dst.suffix}"
                        rename_plan[idx] = (fp, new_dst, orig_id)

            # --- 3) 処理実行 ---
            os.makedirs(dst_root, exist_ok=True)
            total = len(rename_plan)
            processed = 0
            errors = 0

            for fp, dst, orig_id in rename_plan:
                rel = fp.relative_to(src_root)
                dst_rel = dst.relative_to(dst_root)
                os.makedirs(dst.parent, exist_ok=True)

                ok, msg = self._anon_dicom(str(fp), str(dst), tags)
                if ok:
                    if str(rel) != str(dst_rel):
                        self._log(f"  [DICOM]        {rel} -> {dst_rel}")
                    else:
                        self._log(f"  [DICOM]        {rel}")
                else:
                    self._log(f"  [DICOM ERROR]  {rel}: {msg}")
                    errors += 1

                processed += 1
                if total > 0:
                    self._thread_call(lambda p=processed / total: self.progress.set(p))
                self._thread_call(lambda p=processed, t=total:
                           self.status_label.configure(text=f"処理中... {p}/{t}"))

            summary = f"{processed} DICOMファイル処理 / {non_dicom_count} スキップ"
            if errors:
                summary += f" / {errors} エラー"
            self._log(f"完了: {summary} → {dst_root}")

            self.last_output_dir = dst_root
            self._right_output_dir = dst_root
            self._thread_call(lambda: self._on_forward_complete(summary, dst_root))

        except Exception as e:
            self._log(f"エラー: {e}")
            self._thread_call(lambda err=str(e): messagebox.showerror("エラー", err))
            self._thread_call(lambda: self._set_ui_state("idle"))
        finally:
            self.processing = False

    def _on_forward_complete(self, summary, dst_root):
        """匿名化完了時のメインスレッド処理"""
        self._set_ui_state("done_forward")
        self.status_label.configure(text=f"完了: {summary}")
        self.open_btn.configure(state="normal")
        messagebox.showinfo("完了", f"匿名化完了\n{summary}\n\n出力: {dst_root}")

    def _on_reverse_complete(self, summary, dst_root):
        """匿名化解除完了時のメインスレッド処理"""
        self._set_ui_state("done_reverse")
        self.status_label.configure(text=f"匿名化解除完了: {summary}")
        self.open_btn.configure(state="normal")
        messagebox.showinfo("完了", f"匿名化解除完了\n{summary}\n\n出力: {dst_root}")

    # --------------------------------------------------------
    # ファイル処理ヘルパー
    # --------------------------------------------------------

    @staticmethod
    def _is_dicom(fp: Path) -> bool:
        if not HAS_PYDICOM:
            return False
        ext = fp.suffix.lower()
        if ext == ".dcm":
            return True
        if ext != "":
            return False
        try:
            with open(fp, "rb") as f:
                f.seek(128)
                return f.read(4) == b"DICM"
        except Exception:
            return False

    @staticmethod
    def _anon_dicom(inp: str, outp: str, tags: dict):
        try:
            ds = pydicom.dcmread(inp)
        except Exception as e:
            return False, str(e)
        for t, v in tags.items():
            if hasattr(ds, t):
                setattr(ds, t, v)
        os.makedirs(os.path.dirname(outp), exist_ok=True)
        try:
            ds.save_as(outp)
            return True, ""
        except Exception as e:
            return False, str(e)

    def _process_text(self, src, dst, orig_id, anon_id, rel):
        for enc in ("utf-8", "utf-8-sig", "cp932"):
            try:
                content = src.read_text(encoding=enc)
                content = content.replace(orig_id, anon_id)
                dst.write_text(content, encoding="utf-8")
                self._log(f"  [content+name] {rel}")
                return
            except (UnicodeDecodeError, UnicodeError):
                continue
        shutil.copy2(str(src), str(dst))
        self._log(f"  [copy]         {rel} (encoding error)")

    def _process_rich_text(self, src, dst, orig_id, anon_id, rel, ext):
        """JSON / XML ファイル内の ID を置換"""
        try:
            if ext == ".json":
                for enc in ("utf-8", "utf-8-sig", "cp932"):
                    try:
                        raw = src.read_text(encoding=enc)
                        break
                    except (UnicodeDecodeError, UnicodeError):
                        continue
                else:
                    shutil.copy2(str(src), str(dst))
                    self._log(f"  [copy]         {rel} (encoding error)")
                    return
                raw = raw.replace(orig_id, anon_id)
                dst.write_text(raw, encoding="utf-8")
                self._log(f"  [json]         {rel}")

            elif ext == ".xml":
                for enc in ("utf-8", "utf-8-sig", "cp932"):
                    try:
                        raw = src.read_text(encoding=enc)
                        break
                    except (UnicodeDecodeError, UnicodeError):
                        continue
                else:
                    shutil.copy2(str(src), str(dst))
                    self._log(f"  [copy]         {rel} (encoding error)")
                    return
                raw = raw.replace(orig_id, anon_id)
                dst.write_text(raw, encoding="utf-8")
                self._log(f"  [xml]          {rel}")

        except Exception as e:
            shutil.copy2(str(src), str(dst))
            self._log(f"  [copy]         {rel} ({e})")

    def _process_xlsx(self, src, dst, orig_id, anon_id, rel):
        """Excel (.xlsx) ファイル内の ID を置換"""
        try:
            wb = openpyxl.load_workbook(str(src))
            replaced = False
            for ws in wb.worksheets:
                for row in ws.iter_rows():
                    for cell in row:
                        if cell.value is not None and isinstance(cell.value, str):
                            if orig_id in cell.value:
                                cell.value = cell.value.replace(orig_id, anon_id)
                                replaced = True
            wb.save(str(dst))
            if replaced:
                self._log(f"  [xlsx]         {rel}")
            else:
                self._log(f"  [xlsx copy]    {rel}")
        except Exception as e:
            shutil.copy2(str(src), str(dst))
            self._log(f"  [copy]         {rel} (xlsx error: {e})")

    def _process_ooxml(self, src, dst, orig_id, anon_id, rel, ext):
        """Word (.docx) / PowerPoint (.pptx) ファイル内の ID を置換
        Office Open XML は ZIP の中に XML が格納されている構造なので、
        各 XML/.rels ファイル内のテキストを文字列置換する。
        """
        try:
            replaced = False
            with zipfile.ZipFile(str(src), "r") as zin:
                with zipfile.ZipFile(str(dst), "w", zipfile.ZIP_DEFLATED) as zout:
                    for item in zin.infolist():
                        data = zin.read(item.filename)
                        if item.filename.endswith((".xml", ".rels")):
                            try:
                                text = data.decode("utf-8")
                                if orig_id in text:
                                    text = text.replace(orig_id, anon_id)
                                    replaced = True
                                data = text.encode("utf-8")
                            except (UnicodeDecodeError, UnicodeError):
                                pass
                        zout.writestr(item, data)
            label = ext.lstrip(".")
            if replaced:
                self._log(f"  [{label}]        {rel}")
            else:
                self._log(f"  [{label} copy]   {rel}")
        except Exception as e:
            shutil.copy2(str(src), str(dst))
            self._log(f"  [copy]         {rel} ({ext} error: {e})")

    # --------------------------------------------------------
    # 親DIR直下ファイル匿名化
    # --------------------------------------------------------

    @staticmethod
    def _detect_columns(headers, data_rows, known_ids_set, id_digits):
        """ID列: 値ベース (既知ID一致数 or 桁数パターン + 日付除外)。
        名前列: ヘッダキーワードベース。

        ID判定ロジック:
          A) 既知IDと2件以上一致 かつ 日付が過半数でない → ID列
          B) Aに該当しない場合のフォールバック:
             70%以上がid_digits桁の数値 かつ 日付が過半数でない → ID列

        Returns: (id_col_indices, name_col_indices)
        """
        id_cols = []
        name_cols = []

        for idx, raw_header in enumerate(headers):
            h = re.sub(r'[\s_\-\u3000]', '', raw_header.strip()).lower()

            # === ID列: 値ベース検出 ===
            col_vals = [
                str(row[idx]).strip() for row in data_rows
                if idx < len(row) and row[idx] is not None
                and str(row[idx]).strip()
            ]
            if col_vals:
                match_count = 0
                date_count = 0
                digit_len_count = 0

                for v in col_vals:
                    # 既知IDとの一致 (0埋め補正あり)
                    if known_ids_set:
                        if v in known_ids_set:
                            match_count += 1
                        elif (v.isdigit()
                              and v.zfill(id_digits) in known_ids_set):
                            match_count += 1

                    # 日付らしい値 (YYYYMMDD or Excelシリアル)
                    if _DATE_YYYYMMDD.match(v):
                        date_count += 1
                    elif v.isdigit() and id_digits >= 5:
                        try:
                            if 1 <= int(v) <= _DATE_SERIAL_MAX:
                                date_count += 1
                        except ValueError:
                            pass

                    # id_digits桁の数値かどうか
                    if v.isdigit():
                        padded = v.zfill(id_digits)
                        if len(padded) == id_digits and len(v) <= id_digits:
                            digit_len_count += 1

                n = len(col_vals)
                date_ratio = date_count / n

                is_id = False
                # A) 既知IDと2件以上一致 (7桁で偶然2件一致する確率≒0)
                if match_count >= 2 and date_ratio < 0.5:
                    is_id = True
                # B) フォールバック: 70%以上がid_digits桁 & 日付でない
                elif match_count == 0 and digit_len_count / n >= 0.7 \
                        and date_ratio < 0.5:
                    is_id = True

                if is_id:
                    id_cols.append(idx)

            # === 名前列: ヘッダキーワード ===
            name_score = 0
            if any(kw in h for kw in _NAME_KW_STRONG):
                name_score = 3
            elif any(kw in h for kw in _NAME_KW_MEDIUM):
                name_score = 3
            elif h in _NAME_KW_EXACT:
                name_score = 2

            if name_score >= 2:
                name_cols.append(idx)

        return id_cols, name_cols

    def _anon_parent_csv(self, src, dst, id_map, known_set,
                         id_digits, prefix, mode):
        """親DIR直下の CSV/TSV を匿名化。"""
        delimiter = '\t' if src.suffix.lower() == '.tsv' else ','

        rows = None
        for enc in ("utf-8", "utf-8-sig", "cp932"):
            try:
                with open(src, 'r', encoding=enc, newline='') as f:
                    rows = list(csv.reader(f, delimiter=delimiter))
                break
            except (UnicodeDecodeError, UnicodeError):
                continue

        if not rows or len(rows) < 2:
            shutil.copy2(str(src), str(dst))
            return None

        headers = rows[0]
        data_rows = rows[1:]

        id_cols, name_cols = self._detect_columns(
            headers, data_rows, known_set, id_digits)

        if not id_cols and not name_cols:
            shutil.copy2(str(src), str(dst))
            return None

        replaced = 0
        for row in data_rows:
            anon_id = None
            for ic in id_cols:
                if ic >= len(row):
                    continue
                v = str(row[ic]).strip()
                if not v:
                    continue
                # 直接一致
                if v in id_map:
                    anon_id = id_map[v]
                    row[ic] = anon_id
                    replaced += 1
                    break
                # 0埋め一致
                if v.isdigit():
                    padded = v.zfill(id_digits)
                    if padded in id_map:
                        anon_id = id_map[padded]
                        row[ic] = anon_id
                        replaced += 1
                        break
                    # Feistel: 桁数が合えばその場で暗号化
                    if mode == "feistel" and len(padded) == id_digits:
                        try:
                            anon_id = protect_id(
                                padded, self.key, id_digits, prefix)
                            id_map[padded] = anon_id
                            row[ic] = anon_id
                            replaced += 1
                            break
                        except Exception:
                            pass

            # IDが特定できた行のみ名前列を空白化
            if anon_id:
                for nc in name_cols:
                    if nc < len(row) and row[nc]:
                        row[nc] = ""
                        replaced += 1

        os.makedirs(dst.parent, exist_ok=True)
        with open(dst, 'w', encoding='utf-8-sig', newline='') as f:
            writer = csv.writer(f, delimiter=delimiter)
            writer.writerow(headers)
            writer.writerows(data_rows)

        desc = []
        if id_cols:
            desc.append("ID列: " + ", ".join(
                headers[i] for i in id_cols if i < len(headers)))
        if name_cols:
            desc.append("名前列: " + ", ".join(
                headers[i] for i in name_cols if i < len(headers)))
        return f"{replaced}箇所置換 ({'; '.join(desc)})"

    def _anon_parent_xlsx(self, src, dst, id_map, known_set,
                          id_digits, prefix, mode):
        """親DIR直下の Excel (.xlsx) を匿名化。"""
        try:
            wb = openpyxl.load_workbook(str(src))
        except Exception as e:
            shutil.copy2(str(src), str(dst))
            return f"読込エラー ({e})"

        total_replaced = 0
        sheets_info = []

        for ws in wb.worksheets:
            headers = []
            for cell in ws[1]:
                headers.append(str(cell.value) if cell.value is not None else "")
            if not headers or ws.max_row < 2:
                continue

            data_rows = []
            for row in ws.iter_rows(min_row=2, values_only=True):
                data_rows.append(
                    [str(v) if v is not None else "" for v in row])

            id_cols, name_cols = self._detect_columns(
                headers, data_rows, known_set, id_digits)
            if not id_cols and not name_cols:
                continue

            for row in ws.iter_rows(min_row=2):
                anon_id = None
                for ic in id_cols:
                    if ic >= len(row):
                        continue
                    cell = row[ic]
                    v = str(cell.value).strip() if cell.value is not None else ""
                    if not v:
                        continue
                    if v in id_map:
                        anon_id = id_map[v]
                        cell.value = anon_id
                        total_replaced += 1
                        break
                    if v.isdigit():
                        padded = v.zfill(id_digits)
                        if padded in id_map:
                            anon_id = id_map[padded]
                            cell.value = anon_id
                            total_replaced += 1
                            break
                        if mode == "feistel" and len(padded) == id_digits:
                            try:
                                anon_id = protect_id(
                                    padded, self.key, id_digits, prefix)
                                id_map[padded] = anon_id
                                cell.value = anon_id
                                total_replaced += 1
                                break
                            except Exception:
                                pass

                if anon_id:
                    for nc in name_cols:
                        if nc < len(row) and row[nc].value:
                            row[nc].value = ""
                            total_replaced += 1

            cols = []
            if id_cols:
                cols.append("ID: " + ", ".join(
                    headers[i] for i in id_cols if i < len(headers)))
            if name_cols:
                cols.append("名前: " + ", ".join(
                    headers[i] for i in name_cols if i < len(headers)))
            sheets_info.append(f"{ws.title}({'; '.join(cols)})")

        os.makedirs(dst.parent, exist_ok=True)
        wb.save(str(dst))

        if total_replaced == 0:
            return None
        return f"{total_replaced}箇所置換 [{', '.join(sheets_info)}]"

    def _log(self, msg: str):
        def _update():
            self.log_box.configure(state="normal")
            ts = datetime.now().strftime("%H:%M:%S")
            self.log_box.insert("end", f"[{ts}] {msg}\n")
            self.log_box.see("end")
            self.log_box.configure(state="disabled")
        self._thread_call(_update)

    # --------------------------------------------------------
    # ダイアログ
    # --------------------------------------------------------

    def _open_dicom_settings(self):
        DicomSettingsDialog(self, self.tag_vars, self.tag_entries)

    def _open_password_dialog(self):
        PasswordDialog(self, on_saved=self._on_password_saved)

    def _on_password_saved(self, new_password: str):
        self.key = derive_key(new_password)
        # ボタンを「設定済」の押し込まれた見た目に切替
        self.pw_btn.configure(
            text="SEED値 設定済",
            fg_color=("#D1D5DB", "#374151"),
            text_color=("#9CA3AF", "#6B7280"),
            border_width=0,
            hover_color=("#D1D5DB", "#374151"),
            state="disabled",
        )

    # --------------------------------------------------------
    # 起動
    # --------------------------------------------------------

    def run(self):
        self.mainloop()


if __name__ == "__main__":
    app = AnonymizerApp()
    app.run()