NAIA/wd14_test_v2.py

import tkinter as tk
from tkinter import filedialog, messagebox, scrolledtext, ttk
from PIL import Image, ImageTk, ImageGrab
import threading
import os
import numpy as np
import pandas as pd
import cv2
import tempfile
import io
import json
import sys
import time # 시간 측정용
from datetime import datetime # 폴더명 생성용
import subprocess # 폴더 열기용
import win32clipboard
import random

# resource_path 함수는 변경 없이 그대로 사용합니다.
def resource_path(relative_path):
    """ PyInstaller에 의해 임시 폴더에 생성된 리소스의 절대 경로를 반환합니다. """
    try:
        base_path = sys._MEIPASS
    except Exception:
        base_path = os.path.abspath(".")
    return os.path.join(base_path, relative_path)

class WD14TaggerGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("WD14 Auto Prompt Generator (aiart) v2")
        
        self.root.minsize(680, 800)
        self.root.resizable(True, True)

        self.SETTINGS_FILE = "tagger_app_settings.json"

        # --- 변수 초기화 ---
        self.current_image_path = None
        self.session = None
        self.tags_df = None
        self.is_generating = False
        self.save_counter = 1
        self.last_generated_image = None
        self.temp_image_path = os.path.join(tempfile.gettempdir(), "wd14_temp_generated.png")
        self.save_session_folder = datetime.now().strftime('%Y%m%d_%H%M')

        # Tkinter 변수
        self.general_threshold_var = tk.DoubleVar(value=0.5)
        self.char_threshold_var = tk.DoubleVar(value=0.85)
        self.rm_c_var = tk.BooleanVar()
        self.rm_color_var = tk.BooleanVar()
        self.rm_clothes_var = tk.BooleanVar()
        self.webui_mode_var = tk.BooleanVar()
        self.instant_inference_var = tk.BooleanVar(value=False)
        self.show_removed_tags_var = tk.BooleanVar(value=True)
        self.show_ignore_tags_var = tk.BooleanVar(value=False)
        self.prompt_active_var = tk.BooleanVar(value=False)
        self.expand_ui_var = tk.BooleanVar(value=False)
        self.sampler_var = tk.StringVar()
        self.resolution_var = tk.StringVar()
        self.steps_var = tk.StringVar(value="28")
        self.scale_var = tk.StringVar(value="5.5")
        self.seed_var = tk.StringVar(value="-1")
        self.cfg_rescale_var = tk.StringVar(value="0.25")
        self.nai_token_var = tk.StringVar()
        self.model_var = tk.StringVar()
        self.auto_save_var = tk.BooleanVar(value=True)
        self.instant_generate_var = tk.BooleanVar(value=False)
        self.auto_rating_tag_var = tk.BooleanVar(value=True)
        self.character_prompts = []
        self.char_check_vars = [tk.BooleanVar(value=False) for _ in range(3)]
        self.char_check_vars[0].set(True)
        self.last_generated_seed = random.randint(0, 9999999999)

        self.init_filter_data()
        self.setup_ui()
        self.load_model()
        self.show_initial_preview()
        self.setup_drag_drop()
        self.load_settings()
        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
        self.root.bind('<Control-v>', self.handle_paste)

    def _create_thumbnail(self, pil_image, size=512):
        """PIL 이미지를 받아 흰 배경의 정사각형 썸네일을 생성합니다."""
        # 1. 원본 이미지의 너비와 높이 중 더 큰 쪽을 기준으로 정사각형 캔버스 생성
        bg_size = max(pil_image.size)
        thumbnail_bg = Image.new('RGB', (bg_size, bg_size), 'white')
        
        # 2. 캔버스 중앙에 원본 이미지 붙여넣기
        paste_x = (bg_size - pil_image.width) // 2
        paste_y = (bg_size - pil_image.height) // 2
        thumbnail_bg.paste(pil_image, (paste_x, paste_y))
        
        # 3. 최종 썸네일 크기로 리사이즈
        thumbnail_bg.thumbnail((size, size), Image.Resampling.LANCZOS)
        return thumbnail_bg

    def _update_timer(self):
        """생성 버튼의 타이머를 업데이트합니다."""
        if self.is_generating:
            elapsed = time.time() - self.generation_start_time
            self.generation_btn.config(text=f"생성 중: {int(elapsed)}s")
            self.root.after(1000, self._update_timer) # 1초마다 반복

    def _copy_image_to_clipboard(self):
        """생성된 이미지를 클립보드에 복사합니다 (Windows 전용)."""
        if self.last_generated_image is None:
            messagebox.showinfo("정보", "복사할 이미지가 없습니다.")
            return

        if win32clipboard is None:
            messagebox.showerror("오류", "이미지 복사 기능을 사용하려면 'pywin32' 라이브러리가 필요합니다.\n(pip install pywin32)")
            return

        if sys.platform == "win32":
            try:
                output = io.BytesIO()
                self.last_generated_image.convert("RGB").save(output, "BMP")
                data = output.getvalue()[14:]
                output.close()
                win32clipboard.OpenClipboard()
                win32clipboard.EmptyClipboard()
                win32clipboard.SetClipboardData(win32clipboard.CF_DIB, data)
                win32clipboard.CloseClipboard()
                #messagebox.showinfo("성공", "이미지를 클립보드에 복사했습니다.")
            except Exception as e:
                messagebox.showerror("복사 실패", f"이미지 복사 중 오류 발생: {e}")
        else:
            messagebox.showinfo("정보", "이미지 복사 기능은 Windows에서만 지원됩니다.")

    def _copy_file_object_to_clipboard(self):
        """임시 저장된 이미지 파일을 클립보드에 파일 객체로 복사합니다 (Windows 전용)."""
        if not os.path.exists(self.temp_image_path):
            messagebox.showinfo("정보", "복사할 파일이 없습니다.")
            return

        if sys.platform == "win32":
            try:
                command = f"powershell -command \"Get-Item '{self.temp_image_path}' | Set-Clipboard\""
                subprocess.run(command, check=True, shell=True, creationflags=subprocess.CREATE_NO_WINDOW)
                #messagebox.showinfo("성공", "파일을 클립보드에 복사했습니다.")
            except Exception as e:
                messagebox.showerror("복사 실패", f"파일 복사 중 오류 발생: {e}")
        else:
            messagebox.showinfo("정보", "파일 복사 기능은 Windows에서만 지원됩니다.")

    def _show_context_menu(self, event):
        """이미지 레이블 위에서 우클릭 시 컨텍스트 메뉴를 표시합니다."""
        if self.last_generated_image:
            self.image_context_menu.tk_popup(event.x_root, event.y_root)

    def _save_image_manual(self):
        """(수정됨) 이미지를 자동 저장 폴더에 순차적으로 저장합니다."""
        if self.last_generated_image is None:
            messagebox.showinfo("정보", "저장할 이미지가 없습니다.")
            return
        
        try:
            save_dir = os.path.join("Output_WD14", self.save_session_folder)
            os.makedirs(save_dir, exist_ok=True)
            file_path = os.path.join(save_dir, f"{self.save_counter:05d}.png")
            self.last_generated_image.save(file_path, "PNG")
            
            #messagebox.showinfo("성공", f"이미지를 {file_path}에 저장했습니다.")
            self.save_counter += 1
            self.save_btn.config(state=tk.DISABLED) # 저장 후 버튼 비활성화
        except Exception as e:
            messagebox.showerror("저장 실패", f"이미지 저장 중 오류 발생: {e}")

    def _open_save_folder(self):
        """자동 저장 폴더를 엽니다."""
        session_path = os.path.join("Output_WD14", self.save_session_folder)
        base_path = "Output_WD14"
        
        try:
            if os.path.isdir(session_path):
                path_to_open = session_path
            elif os.path.isdir(base_path):
                path_to_open = base_path
            else:
                messagebox.showinfo("정보", f"'{base_path}' 폴더를 찾을 수 없습니다.")
                return

            if sys.platform == "win32":
                os.startfile(os.path.realpath(path_to_open))
            elif sys.platform == "darwin":
                subprocess.Popen(["open", os.path.realpath(path_to_open)])
            else:
                subprocess.Popen(["xdg-open", os.path.realpath(path_to_open)])
        except Exception as e:
            messagebox.showerror("오류", f"폴더를 여는 중 오류 발생: {e}")

    # Step 2 & 3 & 4의 로직을 처리할 메서드
    def toggle_expand_ui(self):
        """체크박스 상태에 따라 우측 UI와 '즉시 생성' 버튼의 가시성을 제어합니다."""
        main_frame = self.right_pane.master
        if self.expand_ui_var.get():
            main_frame.grid_columnconfigure(1, weight=1, minsize=400)
            self.right_pane.grid(row=0, column=1, sticky="nsew")
            self.root.minsize(1220, 800)
            # '즉시 생성' 체크박스 표시
            self.instant_generate_cb.pack(side=tk.LEFT, padx=(5,0))
        else:
            self.right_pane.grid_forget()
            main_frame.grid_columnconfigure(1, weight=0, minsize=0)
            self.root.minsize(680, 800)
            # '즉시 생성' 체크박스 숨김
            self.instant_generate_cb.pack_forget()

    # Step 3의 로직을 처리할 메서드
    def show_generation_preview(self):
        """우측 패널에 512x512 흰색 이미지를 표시합니다."""
        try:
            white_image = Image.new('RGB', (512, 512), 'white')
            photo = ImageTk.PhotoImage(white_image)
            # PhotoImage 객체에 대한 참조를 유지하여 가비지 컬렉션을 방지
            self.generation_image_label.image = photo
            self.generation_image_label.config(image=photo)
        except Exception as e:
            self.generation_image_label.config(text=f"이미지 표시 오류: {e}")

    def random_seed(self):
        if int(self.seed_var.get()) == -1:
            self.seed_var.set(str(self.last_generated_seed))
        else:
            self.seed_var.set("-1")
    
    def setup_ui(self):
        # ... (기존 setup_ui의 시작 부분은 동일) ...
        self.root.grid_columnconfigure(0, weight=1)
        self.root.grid_rowconfigure(0, weight=1)

        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.grid(row=0, column=0, sticky="nsew")
        
        main_frame.grid_columnconfigure(0, weight=1) 
        main_frame.grid_columnconfigure(1, weight=1, minsize=400)
        
        main_frame.grid_rowconfigure(0, weight=1)

        # --- 좌측 UI 패널 ---
        left_pane = ttk.Frame(main_frame)
        left_pane.grid(row=0, column=0, sticky="nsew")
        left_pane.grid_columnconfigure(0, weight=1)
        left_pane.grid_rowconfigure(2, weight=4)
        left_pane.grid_rowconfigure(3, weight=3)

        # ... (좌측 패널의 모든 UI 구성은 기존과 동일) ...
        load_frame = ttk.Frame(left_pane)
        load_frame.grid(row=0, column=0, sticky="ew", pady=(0, 10))
        self.load_btn = ttk.Button(load_frame, text="이미지 불러오기", command=self.load_image)
        self.load_btn.pack(side="left", padx=(0, 5))
        self.clipboard_btn = ttk.Button(load_frame, text="이미지 불러오기 (클립보드)", command=self.load_from_clipboard)
        self.clipboard_btn.pack(side="left")
        self.expand_ui_cb = ttk.Checkbutton(load_frame, text="생성 UI 확장",
                                            variable=self.expand_ui_var,
                                            command=self.toggle_expand_ui)
        self.expand_ui_cb.pack(side="left", padx=(10, 0))
        content_frame = ttk.Frame(left_pane)
        content_frame.grid(row=1, column=0, sticky="new")
        content_frame.grid_columnconfigure(1, weight=1)
        self.preview_frame = ttk.LabelFrame(content_frame, text="미리보기", padding="10")
        self.preview_frame.grid(row=0, column=0, sticky="n", padx=(0, 10))
        self.image_label = ttk.Label(self.preview_frame)
        self.image_label.grid(row=0, column=0)
        settings_frame = ttk.LabelFrame(content_frame, text="설정", padding="10")
        settings_frame.grid(row=0, column=1, sticky="nsew")
        settings_frame.grid_columnconfigure(1, weight=1)
        threshold_frame = ttk.Frame(settings_frame)
        threshold_frame.grid(row=0, column=0, columnspan=2, sticky="ew")
        threshold_frame.grid_columnconfigure(1, weight=1)
        ttk.Label(threshold_frame, text="태그 임계값:").grid(row=0, column=0, sticky="w")
        ttk.Spinbox(threshold_frame, from_=0.0, to=1.0, increment=0.05,
                    textvariable=self.general_threshold_var, width=15).grid(row=0, column=1, sticky="we", pady=(0, 5))
        
        extract_control_frame = ttk.Frame(settings_frame)
        extract_control_frame.grid(row=1, column=0, columnspan=2, pady=5, sticky="ew")
        
        self.extract_btn = ttk.Button(extract_control_frame, text="태그 추출", command=self.extract_tags, state='disabled')
        self.extract_btn.pack(side=tk.LEFT, padx=(0, 10))
        
        self.instant_inference_cb = ttk.Checkbutton(extract_control_frame, text="즉시 추론", variable=self.instant_inference_var)
        self.instant_inference_cb.pack(side=tk.LEFT)

        # '즉시 생성' 체크박스 생성 (초기에는 숨겨짐)
        self.instant_generate_cb = ttk.Checkbutton(extract_control_frame, text="즉시 생성", variable=self.instant_generate_var)

        filter_frame = ttk.LabelFrame(settings_frame, text="태그 필터링", padding="5")
        filter_frame.grid(row=2, column=0, columnspan=2, sticky="ew", pady=(5, 0))
        ttk.Checkbutton(filter_frame, text="캐릭터 특징+이름 제거", 
                        variable=self.rm_c_var).pack(anchor="w")
        ttk.Checkbutton(filter_frame, text="의류 색상 제거", 
                        variable=self.rm_color_var).pack(anchor="w")
        ttk.Checkbutton(filter_frame, text="WEBUI/Comfy 모드", 
                        variable=self.webui_mode_var).pack(anchor="w")
        prompt_outer_frame = ttk.Frame(settings_frame)
        prompt_outer_frame.grid(row=3, column=0, columnspan=2, sticky="ew", pady=(10, 0))
        prompt_outer_frame.grid_columnconfigure(0, weight=1)
        self.prompt_active_cb = ttk.Checkbutton(prompt_outer_frame, text="선행/후행 프롬프트 활성",
                                               variable=self.prompt_active_var,
                                               command=self.toggle_prompts)
        self.prompt_active_cb.grid(row=0, column=0, sticky="w")
        self.prompt_notebook = ttk.Notebook(prompt_outer_frame)
        prefix_frame = ttk.Frame(self.prompt_notebook, padding=5)
        self.prompt_notebook.add(prefix_frame, text="선행 프롬프트")
        self.prefix_text = scrolledtext.ScrolledText(prefix_frame, height=3, width=30)
        self.prefix_text.pack(fill="both", expand=True)
        suffix_frame = ttk.Frame(self.prompt_notebook, padding=5)
        self.prompt_notebook.add(suffix_frame, text="후행 프롬프트")
        self.suffix_text = scrolledtext.ScrolledText(suffix_frame, height=3, width=30)
        self.suffix_text.pack(fill="both", expand=True)
        self.toggle_prompts()
        result_frame = ttk.LabelFrame(left_pane, text="추출된 태그", padding="10")
        result_frame.grid(row=2, column=0, sticky="nsew", pady=(10, 0))
        result_frame.grid_columnconfigure(0, weight=1)
        result_frame.grid_rowconfigure(0, weight=3)
        result_frame.grid_rowconfigure(3, weight=2)
        self.result_text = scrolledtext.ScrolledText(result_frame, height=7, wrap=tk.WORD)
        self.result_text.grid(row=0, column=0, sticky="nsew")
        self.result_text.tag_config("prompt", foreground="grey")
        copy_frame = ttk.Frame(result_frame)
        copy_frame.grid(row=1, column=0, pady=(10, 5), sticky="w")
        ttk.Button(copy_frame, text="전체 복사", command=self.copy_all_tags).pack(side="left", padx=(0, 5))
        ttk.Button(copy_frame, text="2번 태그부터 복사", command=self.copy_from_second).pack(side="left", padx=5)
        ttk.Button(copy_frame, text="3번 태그부터 복사", command=self.copy_from_third).pack(side="left", padx=5)
        auto_rating_cb = ttk.Checkbutton(copy_frame, text="nsfw/safe 태그 자동 반영", variable=self.auto_rating_tag_var)
        auto_rating_cb.pack(side="left", padx=10)
        self.removed_tags_cb = ttk.Checkbutton(result_frame, text="제거된 태그 보기",
                                               variable=self.show_removed_tags_var,
                                               command=self.toggle_removed_tags)
        self.removed_tags_cb.grid(row=2, column=0, sticky="w", pady=(10, 2))
        self.removed_tags_text = scrolledtext.ScrolledText(result_frame, height=4, wrap=tk.WORD, state=tk.DISABLED)
        self.removed_tags_text.tag_config("ignored", foreground="red")
        self.toggle_removed_tags()
        bottom_frame = ttk.Frame(left_pane)
        bottom_frame.grid(row=3, column=0, sticky="nsew", pady=(10, 0))
        bottom_frame.grid_columnconfigure(0, weight=1)
        bottom_frame.grid_rowconfigure(1, weight=1)
        bottom_control_frame = ttk.Frame(bottom_frame)
        bottom_control_frame.grid(row=0, column=0, sticky="ew")
        self.ignore_tags_cb = ttk.Checkbutton(bottom_control_frame, text="무시할 태그 편집 (쉼표로 구분)",
                                              variable=self.show_ignore_tags_var,
                                              command=self.toggle_ignore_tags)
        self.ignore_tags_cb.pack(side="left", anchor="w")
        self.save_settings_btn = ttk.Button(bottom_control_frame, text="설정 저장", command=self.save_settings)
        self.save_settings_btn.pack(side="right", anchor="e")
        self.ignore_tags_frame = ttk.Frame(bottom_frame)
        self.ignore_tags_frame.grid_columnconfigure(0, weight=1)
        self.ignore_tags_frame.grid_rowconfigure(0, weight=1)
        self.ignore_tags_text = scrolledtext.ScrolledText(self.ignore_tags_frame, height=4, wrap=tk.WORD)
        self.ignore_tags_text.grid(row=0, column=0, sticky="nsew")
        self.toggle_ignore_tags()


        # --- 우측 UI 패널 ---
        self.right_pane = ttk.Frame(main_frame)
        self.right_pane.grid_rowconfigure(0, weight=1) 
        self.right_pane.grid_rowconfigure(2, weight=0)
        self.right_pane.grid_columnconfigure(0, weight=1)

        generation_preview_frame = ttk.LabelFrame(self.right_pane, text="생성 미리보기", padding="5")
        generation_preview_frame.grid(row=0, column=0, sticky="nsew")
        generation_preview_frame.grid_columnconfigure(0, weight=1)
        generation_preview_frame.grid_rowconfigure(0, weight=1)
        
        self.generation_image_label = ttk.Label(generation_preview_frame, anchor="center")
        self.generation_image_label.grid(row=0, column=0, sticky="nsew")
        self.generation_image_label.bind("<Button-3>", self._show_context_menu) # 우클릭 이벤트 바인딩

        # 컨텍스트 메뉴 생성
        self.image_context_menu = tk.Menu(self.root, tearoff=0)
        self.image_context_menu.add_command(label="이미지를 클립보드에 복사", command=self._copy_image_to_clipboard)
        self.image_context_menu.add_command(label="파일을 클립보드에 복사", command=self._copy_file_object_to_clipboard) 
        self.image_context_menu.add_command(label="기본 뷰어로 이미지 열기", command=self._show_image_with_pil)

        # generation_button_frame 구성 부분 수정
        generation_button_frame = ttk.Frame(self.right_pane)
        generation_button_frame.grid(row=1, column=0, sticky="ew", pady=(5, 0), padx=10)
        
        self.folder_btn = ttk.Button(generation_button_frame, text="📁", width=2, command=self._open_save_folder)
        self.folder_btn.pack(side="right")
        self.save_btn = ttk.Button(generation_button_frame, text="Save 💾", width=8, command=self._save_image_manual)
        self.save_btn.pack(side="right", padx=(5, 0))
        self.copy_btn = ttk.Button(generation_button_frame, text="  Copy 🗃️", width=8, command=self._copy_image_to_clipboard)
        self.copy_btn.pack(side="right", padx=(5, 0))
        
        self.generation_btn = ttk.Button(generation_button_frame, text="Generation", command=self.start_generation)
        self.generation_btn.pack(side="left", fill="x", expand=True)

        # --- Notebook 및 탭 설정 ---
        self.settings_notebook = ttk.Notebook(self.right_pane)
        self.settings_notebook.grid(row=2, column=0, sticky="nsew", pady=(5, 0), padx=10)
        
        # <<<<<<< 핵심 변경점: 모든 탭 프레임을 먼저 생성 >>>>>>>>>
        basic_settings_tab = ttk.Frame(self.settings_notebook, padding="10")
        char_prompt_tab = ttk.Frame(self.settings_notebook, padding=(10, 10, 10, 0))
        account_settings_tab = ttk.Frame(self.settings_notebook, padding="10")

        # <<<<<<< 핵심 변경점: 원하는 순서대로 .add()만 사용 >>>>>>>>>
        self.settings_notebook.add(basic_settings_tab, text="기본설정")
        self.settings_notebook.add(char_prompt_tab, text="캐릭터 프롬프트")
        self.settings_notebook.add(account_settings_tab, text="NAI설정")

        # --- 이제 각 탭의 내용을 채웁니다 ---

        # 1. '기본설정' 탭 내용 구성
        # ... ('기본설정' 탭의 모든 위젯 코드는 여기에 그대로 유지) ...
        basic_settings_tab.grid_columnconfigure(1, weight=1); basic_settings_tab.grid_columnconfigure(3, weight=1); basic_settings_tab.grid_columnconfigure(5, weight=1)
        sampler_list = ["k_euler + native", "k_euler + karras", "k_euler + exponential", "k_euler_ancestral + native", "k_euler_ancestral + karras","k_euler_ancestral + exponential", "k_dpmpp_2s_ancestral + native", "k_dpmpp_2s_ancestral + karras", "k_dpmpp_2s_ancestral + exponential", "k_dpmpp_sde + native", "k_dpmpp_sde + karras", "k_dpmpp_sde + exponential", "k_dpmpp_2m + native", "k_dpmpp_2m + karras", "k_dpmpp_2m + exponential","k_dpmpp_2m_sde + native", "k_dpmpp_2m_sde + karras", "k_dpmpp_2m_sde + exponential"]
        ttk.Label(basic_settings_tab, text="Sampler:").grid(row=0, column=0, sticky="w", padx=(0, 5)); sampler_cb = ttk.Combobox(basic_settings_tab, values=sampler_list, textvariable=self.sampler_var, state="readonly", width=25); sampler_cb.grid(row=0, column=1, sticky="ew"); sampler_cb.set(sampler_list[4])
        ttk.Label(basic_settings_tab, text="Steps:").grid(row=0, column=2, sticky="w", padx=(10, 5)); ttk.Entry(basic_settings_tab, textvariable=self.steps_var, width=5).grid(row=0, column=3, sticky="ew")
        ttk.Label(basic_settings_tab, text="Scale:").grid(row=0, column=4, sticky="w", padx=(10, 5)); ttk.Entry(basic_settings_tab, textvariable=self.scale_var, width=5).grid(row=0, column=5, sticky="ew")
        resolution_list = ["1024 x 1024", "960 x 1088", "896 x 1152", "832 x 1216", "1088 x 960", "1152 x 896", "1216 x 832", "자동 해상도"]
        ttk.Label(basic_settings_tab, text="Resolution:").grid(row=1, column=0, sticky="w", pady=(5, 0), padx=(0, 5)); resolution_cb = ttk.Combobox(basic_settings_tab, values=resolution_list, textvariable=self.resolution_var, state="readonly", width=15); resolution_cb.grid(row=1, column=1, sticky="ew", pady=(5, 0)); resolution_cb.set(resolution_list[2])
        ttk.Label(basic_settings_tab, text="CFG Rescale:").grid(row=1, column=2, sticky="w", pady=(5, 0), padx=(10, 5)); ttk.Entry(basic_settings_tab, textvariable=self.cfg_rescale_var, width=5).grid(row=1, column=3, sticky="ew", pady=(5, 0))
        ttk.Label(basic_settings_tab, text="Seed:").grid(row=1, column=4, sticky="w", pady=(5,0), padx=(10, 5)); seed_frame = ttk.Frame(basic_settings_tab); seed_frame.grid(row=1, column=5, sticky="ew", pady=(5,0)); seed_frame.grid_columnconfigure(0, weight=1); ttk.Entry(seed_frame, textvariable=self.seed_var).pack(side="left", fill="x", expand=True); ttk.Button(seed_frame, text="🎲", width=2, command=self.random_seed).pack(side="right", padx=(5,0))
        uc_header_frame = ttk.Frame(basic_settings_tab)
        uc_header_frame.grid(row=2, column=0, columnspan=6, sticky="ew", pady=(8, 2))

        # 2. 컨테이너 프레임 내부에 기존 레이블과 신규 체크박스 배치
        ttk.Label(uc_header_frame, text="Negative Prompt (UC):").pack(side="left")
        
        auto_save_cb = ttk.Checkbutton(uc_header_frame, text="NAI 생성 이미지를 자동으로 저장", variable=self.auto_save_var)
        auto_save_cb.pack(side="right")
        
        # UC 입력창은 다음 행(row=3)에 배치
        self.uc_text = scrolledtext.ScrolledText(basic_settings_tab, height=4, wrap=tk.WORD)
        self.uc_text.grid(row=3, column=0, columnspan=6, sticky="nsew")

        # 2. '캐릭터 프롬프트' 탭 내용 구성
        char_prompt_tab.grid_columnconfigure(0, weight=1)
        for i in range(3):
            # 각 캐릭터 라인을 담을 프레임
            char_frame = ttk.Frame(char_prompt_tab, padding=(0, 0, 0, 5))
            # <<<<<<< Step 1: 정적 그리드 배치 >>>>>>>>>
            char_frame.grid(row=i, column=0, sticky="ew", pady=2) # 즉시 고정 배치

            # <<<<<<< Step 3: 단일 행 레이아웃 및 3:2 비율 설정 >>>>>>>>>
            # char_frame.grid_columnconfigure(2, weight=3) # P 입력창 가로 비율
            # char_frame.grid_columnconfigure(4, weight=2) # UC 입력창 가로 비율
            
            # 위젯 생성
            check_btn = ttk.Checkbutton(char_frame, text=f"C{i+1}", variable=self.char_check_vars[i], 
                                        command=self.update_character_layout) # style 제거
            
            prompt_label = ttk.Label(char_frame, text="P:")
            prompt_text = scrolledtext.ScrolledText(char_frame, height=1, wrap=tk.WORD, width=46)
            
            uc_label = ttk.Label(char_frame, text="UC:")
            uc_text = scrolledtext.ScrolledText(char_frame, height=1, wrap=tk.WORD, width=24)

            # 위젯 배치 (단일 행 구조)
            check_btn.grid(row=0, column=0, sticky="w", padx=(0, 5))
            prompt_label.grid(row=0, column=1, sticky="w", padx=(0, 2))
            # <<<<<<< Step 3: sticky="ew"로 수정 >>>>>>>>>
            prompt_text.grid(row=0, column=2, sticky="ew") 
            
            uc_label.grid(row=0, column=3, sticky="w", padx=(5, 2))
            uc_text.grid(row=0, column=4, sticky="ew") # sticky="ew"로 수정
            
            self.character_prompts.append({
                "frame": char_frame,
                "check_var": self.char_check_vars[i],
                "prompt_widget": prompt_text,
                "uc_widget": uc_text
            })

        # 3. '계정설정' 탭 내용 구성
        token_frame = ttk.LabelFrame(account_settings_tab, text="Novel AI 영구 토큰 입력")
        token_frame.pack(fill="x", expand=False, padx=5, pady=5)
        token_frame.grid_columnconfigure(0, weight=1)
        token_entry = ttk.Entry(token_frame, textvariable=self.nai_token_var, show="*")
        token_entry.grid(row=0, column=0, sticky="ew", padx=(5,5), pady=5)
        verify_btn = ttk.Button(token_frame, text="검증", command=self.verify_token)
        verify_btn.grid(row=0, column=1, sticky="e", padx=(0,5), pady=5)
        model_frame = ttk.LabelFrame(account_settings_tab, text="모델 설정")
        model_frame.pack(fill="x", expand=False, padx=5, pady=(10, 5))
        model_frame.grid_columnconfigure(0, weight=1)
        model_list = ["nai-diffusion-4-5-full"]
        model_cb = ttk.Combobox(model_frame, values=model_list, textvariable=self.model_var, state="disabled")
        model_cb.grid(row=0, column=0, sticky="ew", padx=5, pady=5)
        model_cb.set(model_list[0])


        # --- UI 초기 상태 설정 ---
        self.show_generation_preview()
        self.update_character_layout() 
        self.toggle_expand_ui()

    def update_character_layout(self):
        for p_info in self.character_prompts:
            if p_info['check_var'].get():
                # 체크된 경우: 입력창 활성화
                p_info['prompt_widget'].config(state=tk.NORMAL)
                p_info['uc_widget'].config(state=tk.NORMAL)
            else:
                # 체크 해제된 경우: 입력창 비활성화
                p_info['prompt_widget'].config(state=tk.DISABLED)
                p_info['uc_widget'].config(state=tk.DISABLED)

    def verify_token(self):
        """[검증] 버튼 클릭 시 토큰 검증 스레드를 시작하는 메서드"""
        token = self.nai_token_var.get()
        if not token:
            messagebox.showwarning("입력 오류", "토큰을 입력해주세요.")
            return

        # 검증 시작을 알림 (선택 사항)
        self.root.config(cursor="watch")
        
        # 별도 스레드에서 API 요청 실행
        thread = threading.Thread(target=self._verify_token_thread, args=(token,))
        thread.daemon = True
        thread.start()

    def _verify_token_thread(self, token):
        """(스레드에서 실행) 실제 API 요청 및 검증 로직"""
        import requests
        
        try:
            response = requests.get(
                "https://api.novelai.net/user/subscription",
                headers={"Authorization": f"Bearer {token}"},
                timeout=5  # 5초 이상 응답 없으면 타임아웃
            )
            response.raise_for_status()  # 200번대 코드가 아니면 예외 발생

            data_dict = response.json()
            
            # Opus 등급(unlimitedMaxPriority) 구독 여부 확인
            if data_dict.get('perks', {}).get('unlimitedMaxPriority', False):
                result_message = "Opus 등급 구독이 확인되었습니다."
                result_type = "info"
            else:
                result_message = "유효한 토큰이나 Opus 등급 구독이 아닙니다."
                result_type = "warning"

        except requests.exceptions.HTTPError as e:
            if e.response.status_code == 401:
                result_message = "인증 실패: 유효하지 않은 토큰입니다."
            else:
                result_message = f"HTTP 오류 발생: {e.response.status_code}"
            result_type = "error"
        except requests.exceptions.RequestException as e:
            result_message = f"네트워크 오류: API 서버에 연결할 수 없습니다.\n{e}"
            result_type = "error"
        except Exception as e:
            result_message = f"알 수 없는 오류 발생: {e}"
            result_type = "error"
        
        # GUI 업데이트는 메인 스레드에서 안전하게 처리
        self.root.after(0, self._update_verification_result, result_type, result_message)

    def _update_verification_result(self, result_type, message):
        """(메인 스레드에서 실행) 검증 결과를 messagebox로 표시"""
        self.root.config(cursor="") # 커서 원래대로
        
        if result_type == "info":
            messagebox.showinfo("검증 성공", message)
        elif result_type == "warning":
            messagebox.showwarning("검증 확인", message)
        else: # error
            messagebox.showerror("검증 실패", message)

    def init_filter_data(self):
        try:
            from tagbag import bag_of_tags, clothes_list
            from character_dictionary import character_dictionary as cd

            self.bag_of_tags = bag_of_tags
            self.clothes_list = clothes_list
            self.character_keys = list(cd.keys()) if isinstance(cd, dict) else []

        except ImportError as e:
            print(f"⚠ NAIA 파일 import 실패: {e}")
            print("기본 데이터를 사용합니다.")
            self.bag_of_tags = [
                'smile', 'blush', 'open_mouth', 'closed_eyes', 'wink', 'frown',
                'twintails', 'ponytail', 'braid', 'long_hair', 'short_hair',
                'large_breasts', 'small_breasts', 'cleavage', 'navel'
            ]
            self.clothes_list = [
                'dress', 'skirt', 'shirt', 'jacket', 'uniform', 'school_uniform'
            ]
            self.character_keys = []

        self.colors = ['black', 'white', 'blond', 'silver', 'gray', 'yellow',
                       'blue', 'purple', 'red', 'pink', 'brown', 'orange',
                       'green', 'aqua', 'gradient']
    
    def toggle_removed_tags(self):
        if self.show_removed_tags_var.get():
            self.removed_tags_text.grid(row=3, column=0, sticky="nsew", pady=(5, 0))
        else:
            self.removed_tags_text.grid_forget()

    def toggle_ignore_tags(self):
        if self.show_ignore_tags_var.get():
            self.ignore_tags_frame.grid(row=1, column=0, sticky="nsew")
        else:
            self.ignore_tags_frame.grid_forget()

    def toggle_prompts(self):
        if self.prompt_active_var.get():
            self.prompt_notebook.grid(row=1, column=0, columnspan=2, sticky="ew", pady=(5, 0))
        else:
            self.prompt_notebook.grid_forget()
            
    def on_closing(self):
        self.save_settings()
        self.root.destroy()

    def save_settings(self):
        """현재 UI의 모든 설정을 JSON 파일에 저장합니다."""
        settings = {
            # 좌측 패널 설정
            'general_threshold': self.general_threshold_var.get(),
            'char_threshold': self.char_threshold_var.get(),
            'rm_c': self.rm_c_var.get(),
            'rm_color': self.rm_color_var.get(),
            'rm_clothes': self.rm_clothes_var.get(),
            'webui_mode': self.webui_mode_var.get(),
            'instant_inference': self.instant_inference_var.get(),
            'ignore_tags': self.ignore_tags_text.get(1.0, tk.END).strip(),
            'show_removed_tags': self.show_removed_tags_var.get(),
            'show_ignore_tags': self.show_ignore_tags_var.get(),
            'prompt_active': self.prompt_active_var.get(),
            'prefix_prompt': self.prefix_text.get(1.0, tk.END).strip(),
            'suffix_prompt': self.suffix_text.get(1.0, tk.END).strip(),
            
            # 우측 패널 (생성 UI) 설정
            'expand_ui': self.expand_ui_var.get(),
            'sampler': self.sampler_var.get(),
            'resolution': self.resolution_var.get(),
            'steps': self.steps_var.get(),
            'scale': self.scale_var.get(),
            'seed': self.seed_var.get(),
            'cfg_rescale': self.cfg_rescale_var.get(),
            'uc_prompt': self.uc_text.get(1.0, tk.END).strip(),
            'nai_token': self.nai_token_var.get()
        }
        settings['auto_save'] = self.auto_save_var.get()
        settings['auto_rating_tag'] = self.auto_rating_tag_var.get()
        # 캐릭터 프롬프트 설정 저장
        char_prompts_data = []
        for p_info in self.character_prompts:
            char_prompts_data.append({
                "checked": p_info['check_var'].get(),
                "prompt": p_info['prompt_widget'].get(1.0, tk.END).strip(),
                "uc": p_info['uc_widget'].get(1.0, tk.END).strip()
            })
        settings['character_prompts'] = char_prompts_data
        try:
            with open(self.SETTINGS_FILE, 'w', encoding='utf-8') as f:
                json.dump(settings, f, indent=4)
        except Exception as e:
            messagebox.showerror("저장 실패", f"설정 저장 중 오류가 발생했습니다: {e}")

    def load_settings(self):
        """JSON 파일에서 설정을 불러와 UI에 적용합니다."""
        try:
            if os.path.exists(self.SETTINGS_FILE):
                with open(self.SETTINGS_FILE, 'r', encoding='utf-8') as f:
                    settings = json.load(f)
                    
                    # 좌측 패널 설정 불러오기
                    self.general_threshold_var.set(settings.get('general_threshold', 0.5))
                    self.char_threshold_var.set(settings.get('char_threshold', 0.85))
                    self.rm_c_var.set(settings.get('rm_c', False))
                    self.rm_color_var.set(settings.get('rm_color', False))
                    self.rm_clothes_var.set(settings.get('rm_clothes', False))
                    self.webui_mode_var.set(settings.get('webui_mode', False))
                    self.instant_inference_var.set(settings.get('instant_inference', False))
                    self.ignore_tags_text.delete(1.0, tk.END)
                    self.ignore_tags_text.insert(1.0, settings.get('ignore_tags', ''))
                    self.show_removed_tags_var.set(settings.get('show_removed_tags', True))
                    self.show_ignore_tags_var.set(settings.get('show_ignore_tags', False))
                    self.prompt_active_var.set(settings.get('prompt_active', False))
                    self.prefix_text.delete(1.0, tk.END)
                    self.prefix_text.insert(1.0, settings.get('prefix_prompt', ''))
                    self.suffix_text.delete(1.0, tk.END)
                    self.suffix_text.insert(1.0, settings.get('suffix_prompt', ''))

                    # 우측 패널 (생성 UI) 설정 불러오기
                    self.expand_ui_var.set(settings.get('expand_ui', False))
                    self.sampler_var.set(settings.get('sampler', 'k_euler_ancestral + karras'))
                    self.resolution_var.set(settings.get('resolution', '896 x 1152'))
                    self.steps_var.set(settings.get('steps', '28'))
                    self.scale_var.set(settings.get('scale', '5.8'))
                    self.seed_var.set(settings.get('seed', '-1'))
                    self.cfg_rescale_var.set(settings.get('cfg_rescale', '0.25'))
                    self.uc_text.delete(1.0, tk.END)
                    self.uc_text.insert(1.0, settings.get('uc_prompt', ''))
                    self.nai_token_var.set(settings.get('nai_token', ''))
                    self.auto_save_var.set(settings.get('auto_save', True))
                    self.auto_rating_tag_var.set(settings.get('auto_rating_tag', True))

                    # 캐릭터 프롬프트 설정 불러오기
                    char_prompts_data = settings.get('character_prompts', [])
                    for i, data in enumerate(char_prompts_data):
                        if i < len(self.character_prompts):
                            p_info = self.character_prompts[i]
                            p_info['check_var'].set(data.get('checked', i==0)) # 기본값은 첫번째만 True
                            
                            p_info['prompt_widget'].delete(1.0, tk.END)
                            p_info['prompt_widget'].insert(1.0, data.get('prompt', ''))
                            
                            p_info['uc_widget'].delete(1.0, tk.END)
                            p_info['uc_widget'].insert(1.0, data.get('uc', ''))
                    
                    # UI 상태 업데이트
                    self.toggle_removed_tags()
                    self.toggle_ignore_tags()
                    self.toggle_prompts()
                    self.update_character_layout() 
                    self.toggle_expand_ui() # 저장된 값에 따라 확장 UI 상태 결정

        except Exception as e:
            messagebox.showwarning("설정 로드 실패", f"설정 파일({self.SETTINGS_FILE})을 불러오는 데 실패했습니다: {e}")
    
    def handle_paste(self, event):
        try:
            clipboard_image = ImageGrab.grabclipboard()
            if isinstance(clipboard_image, Image.Image):
                self.load_from_clipboard()
                return "break"
        except (ValueError, TypeError):
             pass
        except Exception as e:
            print(f"클립보드 이미지 확인 중 오류: {e}")

        try:
            clipboard_text = self.root.clipboard_get()
            if isinstance(clipboard_text, str) and clipboard_text.startswith(('http://', 'https://')):
                self._load_image_from_url(clipboard_text)
                return "break"
            
            image_extensions = ('.jpg', '.jpeg', '.png', '.webp', '.bmp', '.tiff')
            if isinstance(clipboard_text, str) and clipboard_text.lower().endswith(image_extensions):
                path = clipboard_text.strip('"')
                if os.path.exists(path):
                    self._load_image_from_path(path)
                    return "break"

        except tk.TclError:
            pass
        except Exception as e:
            messagebox.showerror("붙여넣기 오류", f"처리 중 오류 발생: {e}")
            return "break"

        return

    def _load_image_from_url(self, url):
        try:
            img = self.download_image_from_url(url)
            temp_dir = tempfile.gettempdir()
            temp_file = os.path.join(temp_dir, f"wd14_url_{os.getpid()}.png")
            img.save(temp_file)
            
            self.current_image_path = temp_file
            self.show_preview(temp_file)
            if self.session is not None:
                self.extract_btn.config(state='normal')
                if self.instant_inference_var.get():
                    self.extract_tags()
        except Exception as e:
            messagebox.showerror("오류", f"웹 이미지 로드 실패: {str(e)}")

    def load_model(self):
        try:
            import onnxruntime as ort
            
            model_path = resource_path("model.onnx")
            tags_path = resource_path("selected_tags.csv")
            
            self.session = ort.InferenceSession(model_path, providers=['CPUExecutionProvider'])
            self.tags_df = pd.read_csv(tags_path)
            
        except Exception as e:
            messagebox.showerror("오류", f"모델 로드 실패: {str(e)}")

    def show_initial_preview(self):
        try:
            white_image = Image.new('RGB', (290, 290), '#F0F0F0')
            photo = ImageTk.PhotoImage(white_image)
            self.image_label.config(image=photo, text="이미지를 Drag & Drop\n또는 붙여넣기(Ctrl+V) 해주세요", compound="center", foreground="gray")
            self.image_label.image = photo
        except Exception as e:
            self.image_label.config(text="이미지를 Drag & Drop 해주세요")

    def setup_drag_drop(self):
        try:
            from tkinterdnd2 import TkinterDnD, DND_ALL
            self.TkdndVersion = TkinterDnD._require(self.root)
            self.image_label.drop_target_register(DND_ALL)
            self.image_label.dnd_bind('<<Drop>>', self.on_drop)
            self.image_label.dnd_bind('<<DragEnter>>', self.on_drag_enter)
            self.image_label.dnd_bind('<<DragLeave>>', self.on_drag_leave)
        except ImportError:
            print("tkinterdnd2가 설치되지 않음. pip install tkinterdnd2로 설치하면 드래그앤드롭을 사용할 수 있습니다.")
        except Exception as e:
            print(f"Drag & Drop 초기화 오류: {e}")

    def on_drag_enter(self, event):
        try:
            self.preview_frame.config(text="미리보기 (이미지를 놓아주세요!)")
        except: pass

    def on_drag_leave(self, event):
        try:
            self.preview_frame.config(text="미리보기")
        except: pass

    def download_image_from_url(self, url):
        import requests
        response = requests.get(url)
        response.raise_for_status()
        return Image.open(io.BytesIO(response.content))

    def on_drop(self, event):
        try:
            if not isinstance(event, str):
                file_path_or_url = event.data.strip("{}")
            else:
                file_path_or_url = event

            if not file_path_or_url:
                messagebox.showwarning("경고", "드롭된 데이터를 읽을 수 없습니다.")
                self.preview_frame.config(text="미리보기")
                return
            
            if file_path_or_url.startswith(('http://', 'https://')):
                self._load_image_from_url(file_path_or_url)
                self.preview_frame.config(text="미리보기")
                return
            else:
                if file_path_or_url.startswith(('blob:')):
                    messagebox.showwarning("Blob URL 오류", "NAI 홈페이지에서 생성한 이미지는 즉시 복사할 수 없습니다.\n이미지를 다운로드한 후 드래그 & 드롭해주세요.")
                    self.preview_frame.config(text="미리보기")
                    return
                
                file_path_or_url = file_path_or_url.replace("\\", '/')
                if os.path.exists(file_path_or_url):
                    self.current_image_path = file_path_or_url
                    self.show_preview(file_path_or_url)
                    if self.session is not None:
                        self.extract_btn.config(state='normal')
                        if self.instant_inference_var.get():
                            self.extract_tags()
                    self.preview_frame.config(text="미리보기")
                else:
                    messagebox.showerror("오류", f"유효하지 않은 파일 경로입니다: '{file_path_or_url}'")
                    self.preview_frame.config(text="미리보기")
                    
        except Exception as e:
            messagebox.showerror("오류", f"파일 드롭 오류: {str(e)}")
            self.preview_frame.config(text="미리보기")
    
    def _load_image_from_path(self, path):
        if os.path.exists(path):
            self.current_image_path = path
            self.show_preview(path)
            if self.session is not None:
                self.extract_btn.config(state='normal')
                if self.instant_inference_var.get():
                    self.extract_tags()
        else:
            messagebox.showwarning("경로 오류", f"파일을 찾을 수 없습니다: {path}")

    def load_from_clipboard(self):
        try:
            image = ImageGrab.grabclipboard()
            if isinstance(image, Image.Image):
                temp_dir = tempfile.gettempdir()
                temp_file = os.path.join(temp_dir, f"wd14_clipboard_{os.getpid()}.png")
                if image.mode == 'RGBA':
                    image = image.convert('RGB')
                image.save(temp_file, 'PNG')
                
                self.current_image_path = temp_file
                self.show_preview(temp_file)
                if self.session is not None:
                    self.extract_btn.config(state='normal')
                    if self.instant_inference_var.get():
                        self.extract_tags()
            else:
                messagebox.showinfo("정보", "클립보드에 이미지가 없습니다.")
        except Exception as e:
            messagebox.showerror("오류", f"클립보드 불러오기 오류: {str(e)}")

    def load_image(self):
        file_path = filedialog.askopenfilename(
            title="이미지 선택",
            filetypes=[("이미지 파일", "*.jpg *.jpeg *.png *.bmp *.tiff *.webp")]
        )
        if file_path:
            self.current_image_path = file_path
            self.show_preview(file_path)
            if self.session is not None:
                self.extract_btn.config(state='normal')
                if self.instant_inference_var.get():
                    self.extract_tags()

    def show_preview(self, image_path):
        try:
            image = Image.open(image_path).convert('RGB')
            size = max(image.size)
            square_image = Image.new('RGB', (size, size), 'white')
            paste_x = (size - image.width) // 2
            paste_y = (size - image.height) // 2
            square_image.paste(image, (paste_x, paste_y))
            square_image.thumbnail((290, 290), Image.Resampling.LANCZOS)
            photo = ImageTk.PhotoImage(square_image)
            self.image_label.config(image=photo, text="")
            self.image_label.image = photo
        except Exception as e:
            self.image_label.config(text=f"이미지 로드 실패: {str(e)}")

    def extract_tags(self):
        if not self.current_image_path or not self.session:
            return
        self.extract_btn.config(state='disabled', text='추출 중...')
        self.result_text.delete(1.0, tk.END)
        self.result_text.insert(tk.END, "태그 추출 중...")
        self.removed_tags_text.config(state=tk.NORMAL)
        self.removed_tags_text.delete(1.0, tk.END) 
        self.removed_tags_text.config(state=tk.DISABLED)
        thread = threading.Thread(target=self._extract_tags_thread)
        thread.daemon = True
        thread.start()

    def _extract_tags_thread(self):
        try:
            input_image = Image.open(self.current_image_path)
            _, height, _, _ = self.session.get_inputs()[0].shape
            image = input_image.convert('RGBA')
            new_image = Image.new('RGBA', image.size, 'WHITE')
            new_image.paste(image, mask=image)
            image = new_image.convert('RGB')
            image = np.asarray(image)[:, :, ::-1]
            image = self.make_square(image, height)
            image = self.smart_resize(image, height)
            image = image.astype(np.float32)
            image = np.expand_dims(image, 0)
            input_name = self.session.get_inputs()[0].name
            label_name = self.session.get_outputs()[0].name
            confidents = self.session.run([label_name], {input_name: image})[0]
            tags_with_conf = []
            for i, conf in enumerate(confidents[0]):
                if i < len(self.tags_df):
                    tags_with_conf.append((self.tags_df.iloc[i]['name'], float(conf)))
            rating_tags = dict(tags_with_conf[:4])
            general_tags = dict(tags_with_conf[4:])
            best_rating = max(rating_tags, key=rating_tags.get) if rating_tags else None
            
            result_tuple = self._format_results(general_tags, best_rating) # best_rating 전달
            self.root.after(0, self._update_results, result_tuple)
        except Exception as e:
            error_msg = f"태그 추출 오류: {str(e)}"
            self.root.after(0, self._update_results, ((None, error_msg, "")))

    def apply_tag_filters(self, tags_list, best_rating=None):
        original_tags = tags_list.copy()
        tags_to_process = [tag.replace('_', ' ') for tag in original_tags]
        
        final_indices = list(range(len(tags_to_process)))
        
        user_removed_originals = []
        other_removed_originals = []

        ignore_list_str = self.ignore_tags_text.get(1.0, tk.END).strip()
        if ignore_list_str:
            user_ignored_tags = {tag.strip().replace('_', ' ') for tag in ignore_list_str.split(',') if tag.strip()}
            indices_to_remove = {i for i in final_indices if tags_to_process[i] in user_ignored_tags}
            for i in indices_to_remove:
                user_removed_originals.append(original_tags[i])
            final_indices = [i for i in final_indices if i not in indices_to_remove]

        if self.rm_c_var.get():
            indices_to_remove = {i for i in final_indices if tags_to_process[i] in self.bag_of_tags or self._is_character_name(tags_to_process[i])}
            for i in indices_to_remove:
                other_removed_originals.append(original_tags[i])
            final_indices = [i for i in final_indices if i not in indices_to_remove]

        if self.rm_color_var.get():
            indices_to_remove = {i for i in final_indices if any(color+" " in tags_to_process[i] for color in self.colors) and " eyes" not in tags_to_process[i] and " hair" not in tags_to_process[i] and " pupils" not in tags_to_process[i]}
            for i in indices_to_remove:
                other_removed_originals.append(original_tags[i])
            final_indices = [i for i in final_indices if i not in indices_to_remove]
        
        if self.rm_clothes_var.get():
            indices_to_remove = {i for i in final_indices if tags_to_process[i] in self.clothes_list and tags_to_process[i] not in self.bag_of_tags}
            for i in indices_to_remove:
                other_removed_originals.append(original_tags[i])
            final_indices = [i for i in final_indices if i not in indices_to_remove]

        final_tags_with_space = [tags_to_process[i] for i in final_indices]


        if self.auto_rating_tag_var.get() and best_rating:
            prefix_str = self.prefix_text.get(1.0, tk.END)
            suffix_str = self.suffix_text.get(1.0, tk.END)

            if not self.webui_mode_var.get():
                best_rating = "rating:" + best_rating
            
            tag_to_add = None
            if best_rating in ["rating:explicit", "rating:questionable", "questionable", "explicit"]:
                if "nsfw" not in prefix_str and "nsfw" not in suffix_str:
                    tag_to_add = best_rating +", nsfw"
            elif best_rating in ["rating:general", "general"]:
                if "safe" not in prefix_str and "safe" not in suffix_str:
                    tag_to_add = best_rating +", safe"
            else:
                tag_to_add = best_rating

            # nsfw/safe 태그 추가
            if tag_to_add:
                person_tags = {'1girl', '2girls', '3girls', '4girls', '5girls', '6+girls', 
                               '1boy', '2boys', '3boys', '4boys', '5boys', '6+boys'}
                insert_pos = 0
                for i, tag in enumerate(final_tags_with_space):
                    if tag in person_tags:
                        insert_pos = i + 1
                        break
                final_tags_with_space.insert(insert_pos, tag_to_add)

        if self.webui_mode_var.get():
            final_tags_formatted = [tag.replace('(', '\\(').replace(')', '\\)') for tag in final_tags_with_space]
        else:
            final_tags_formatted = final_tags_with_space

        final_tags_with_type = [(tag, 'original') for tag in final_tags_formatted]
        if self.prompt_active_var.get():
            prefix_str = self.prefix_text.get(1.0, tk.END).strip()
            if prefix_str:
                prefix_tags = [t.strip() for t in prefix_str.split(',') if t.strip()]
                prefix_tags_with_type = [(tag, 'prompt') for tag in prefix_tags]
                person_tags = {'1girl', '2girls', '3girls', '4girls', '5girls', '6+girls', 
                               '1boy', '2boys', '3boys', '4boys', '5boys', '6+boys'}
                last_person_tag_index = -1
                search_range = min(len(final_tags_with_type), 4)
                for i in range(search_range):
                    if final_tags_with_type[i][0] in person_tags:
                        last_person_tag_index = i
                if last_person_tag_index != -1:
                    final_tags_with_type[last_person_tag_index+1:last_person_tag_index+1] = prefix_tags_with_type
                else:
                    final_tags_with_type[0:0] = prefix_tags_with_type
            
            suffix_str = self.suffix_text.get(1.0, tk.END).strip()
            if suffix_str:
                suffix_tags = [t.strip() for t in suffix_str.split(',') if t.strip()]
                suffix_tags_with_type = [(tag, 'prompt') for tag in suffix_tags]
                final_tags_with_type.extend(suffix_tags_with_type)

        return final_tags_with_type, user_removed_originals, list(set(other_removed_originals))

    def _is_character_name(self, tag):
        if hasattr(self, 'character_keys') and tag in self.character_keys:
            return True
        if ('_' in tag and any(c.isupper() for c in tag) and
            not tag.startswith('1') and
            not any(word in tag.lower() for word in ['girl', 'boy', 'solo', 'multiple']) and
            not any(word in tag.lower() for word in ['hair', 'eye', 'dress', 'shirt']) and
            len(tag) > 3):
            return True
        return False

    def _format_results(self, tags, best_rating=None):
        general_threshold = self.general_threshold_var.get()
        char_threshold = self.char_threshold_var.get()
        
        person_tags = {'1girl', '2girls', '3girls', '4girls', '5girls', '6+girls',
                       '1boy', '2boys', '3boys', '4boys', '5boys', '6+boys',
                       'multiple_girls', 'multiple_boys', 'solo', 'no_humans'}
        
        filtered_tags = []
        for tag, conf in tags.items():
            if tag in person_tags:
                if conf >= 0.9: filtered_tags.append(tag)
            elif any(c.isupper() for c in tag) and '_' in tag and conf >= char_threshold:
                filtered_tags.append(tag)
            elif conf >= general_threshold:
                filtered_tags.append(tag)

        if len(filtered_tags) > 99:
            filtered_tags = filtered_tags[:99]

        final_tags_with_type, user_removed, other_removed = self.apply_tag_filters(filtered_tags, best_rating)
        
        removed_for_display = []
        for tag in user_removed:
            removed_for_display.append((tag, 'ignored'))
        for tag in other_removed:
            if tag not in user_removed:
                removed_for_display.append((tag, 'other'))
        
        return final_tags_with_type, removed_for_display

    def copy_all_tags(self):
        content = self.result_text.get(1.0, tk.END).strip()
        if content:
            self.root.clipboard_clear()
            self.root.clipboard_append(content)
        else:
            messagebox.showwarning("복사 실패", "복사할 태그가 없습니다.")

    def copy_from_second(self):
        self._copy_from_index(1, "2번 태그부터")

    def copy_from_third(self):
        self._copy_from_index(2, "3번 태그부터")

    def _copy_from_index(self, start_index, description):
        content = self.result_text.get(1.0, tk.END).strip()
        if content:
            tags_list = [tag.strip() for tag in content.split(',')]
            if len(tags_list) > start_index:
                selected_tags = tags_list[start_index:]
                result = ', '.join(selected_tags)
                self.root.clipboard_clear()
                self.root.clipboard_append(result)
            else:
                messagebox.showwarning("복사 실패", f"태그가 {start_index + 1}개 미만입니다.")
        else:
            messagebox.showwarning("복사 실패", "복사할 태그가 없습니다.")

    def _update_results(self, result_tuple):
        main_tags_info, removed_tags_info = result_tuple[0], result_tuple[1]
        if len(result_tuple) == 3: # 에러가 아닌 정상 결과일 경우
            main_tags_info, removed_tags_info = result_tuple[1], result_tuple[2]

        # 메인 태그 박스 업데이트
        self.result_text.delete(1.0, tk.END)
        if isinstance(main_tags_info, list):
            for i, (tag, tag_type) in enumerate(main_tags_info):
                if i > 0:
                    self.result_text.insert(tk.END, ', ')
                
                if tag_type == 'prompt':
                    self.result_text.insert(tk.END, tag, 'prompt')
                else:
                    self.result_text.insert(tk.END, tag)
        else: # 오류 메시지 처리
            self.result_text.insert(tk.END, main_tags_info)

        self.removed_tags_text.config(state=tk.NORMAL)
        self.removed_tags_text.delete(1.0, tk.END)
        if removed_tags_info:
            for i, (tag, tag_type) in enumerate(removed_tags_info):
                display_tag = tag.replace('_', ' ')
                
                if i > 0:
                    self.removed_tags_text.insert(tk.END, ', ')
                
                if tag_type == 'ignored':
                    self.removed_tags_text.insert(tk.END, display_tag, 'ignored')
                else:
                    self.removed_tags_text.insert(tk.END, display_tag)
        self.removed_tags_text.config(state=tk.DISABLED)

        self.extract_btn.config(state='normal', text='태그 추출')
        if (self.instant_generate_var.get() and 
            self.expand_ui_var.get() and 
            self.is_generating == False):
            self.start_generation()

    def make_square(self, img, target_size):
        old_size = img.shape[:2]
        desired_size = max(old_size)
        desired_size = max(desired_size, target_size)
        delta_w = desired_size - old_size[1]
        delta_h = desired_size - old_size[0]
        top, bottom = delta_h // 2, delta_h - (delta_h // 2)
        left, right = delta_w // 2, delta_w - (delta_w // 2)
        color = [255, 255, 255]
        new_im = cv2.copyMakeBorder(
            img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color
        )
        return new_im

    def smart_resize(self, img, size):
        if img.shape[0] > size:
            img = cv2.resize(img, (size, size), interpolation=cv2.INTER_AREA)
        elif img.shape[0] < size:
            img = cv2.resize(img, (size, size), interpolation=cv2.INTER_CUBIC)
        return img
    
    def find_max_resolution(self, width, height, max_pixels=1048576, multiple_of=64):
        """가로세로 비율을 유지하며 최대 픽셀 수에 맞는 최대 해상도를 찾습니다."""
        ratio = width / height

        max_width = int((max_pixels * ratio)**0.5)
        max_height = int((max_pixels / ratio)**0.5)

        max_width = (max_width // multiple_of) * multiple_of
        max_height = (max_height // multiple_of) * multiple_of

        while max_width * max_height > max_pixels:
            max_width -= multiple_of
            max_height = int(max_width / ratio)
            max_height = (max_height // multiple_of) * multiple_of

        return (max_width, max_height)

    def start_generation(self):
        if not self.nai_token_var.get():
            messagebox.showerror("토큰 오류", "NAI 설정 탭에서 API 토큰을 먼저 입력해주세요.")
            return
        if not self.result_text.get(1.0, tk.END).strip():
            messagebox.showerror("프롬프트 오류", "좌측 '추출된 태그'에 프롬프트가 없습니다.")
            return

        # --- 수정된 부분 ---
        self.is_generating = True
        self.generation_start_time = time.time()
        self.generation_btn.config(state=tk.DISABLED)
        self.save_btn.config(state=tk.NORMAL)
        self.generation_image_label.config(image=None, text="🎨 이미지 생성 중...")
        self._update_timer() # 타이머 시작
        
        thread = threading.Thread(target=self._generation_thread)
        thread.daemon = True
        thread.start()

    def _generation_thread(self):
        """(백그라운드 스레드) 파라미터 수집, API 요청 및 결과 반환"""
        try:
            # 1. 파라미터 수집 및 전처리
            access_token = self.nai_token_var.get()
            model_name = self.model_var.get()
            main_prompt = self.result_text.get(1.0, tk.END).strip()
            negative_prompt = self.uc_text.get(1.0, tk.END).strip()
            
            # 해상도 처리
            resolution_str = self.resolution_var.get()
            if resolution_str == "자동 해상도":
                if self.current_image_path and os.path.exists(self.current_image_path):
                    with Image.open(self.current_image_path) as img:
                        w, h = img.size
                        width, height = self.find_max_resolution(w, h)
                else: # 불러온 이미지가 없으면 1:1 비율로 계산
                    width, height = self.find_max_resolution(1024, 1024)
            else:
                parts = resolution_str.split(' x ')
                width, height = int(parts[0]), int(parts[1])

            # 샘플러 및 스케줄러 분리
            sampler_parts = self.sampler_var.get().split(' + ')
            sampler = sampler_parts[0]
            noise_schedule = sampler_parts[1] if len(sampler_parts) > 1 else 'karras' # 기본값

            seed = int(self.seed_var.get())
            if seed == -1:
                seed = random.randint(0, 9999999999)
                self.last_generated_seed = seed

            # 2. API Payload 구성
            parameters = {
                "width": width,
                "height": height,
                "n_samples": 1,
                "seed": seed,
                "extra_noise_seed": seed,
                "sampler": sampler,
                "steps": int(self.steps_var.get()),
                "scale": float(self.scale_var.get()),
                "negative_prompt": negative_prompt,
                "cfg_rescale": float(self.cfg_rescale_var.get()),
                "noise_schedule": noise_schedule,
            }

            data = {
                "input": main_prompt,
                "model": model_name,
                "action": "generate",
                "parameters": parameters
            }

            # V4 특화 설정
            if 'nai-diffusion-4' in model_name:
                data['parameters'].update({
                    'params_version': 3,
                    'add_original_image': True,
                    'legacy': False,
                    'legacy_uc': False,
                    'autoSmea': True,
                    'prefer_brownian': True,
                    'ucPreset': 0,
                    'use_coords': False,
                    'v4_negative_prompt': {'caption': {'base_caption': negative_prompt, 'char_captions': []}, 'legacy_uc': False},
                    'v4_prompt': {'caption': {'base_caption': main_prompt, 'char_captions': []}, 'use_coords': False, 'use_order': True}
                })

                # 활성화된 캐릭터 프롬프트 처리
                active_chars = [p for p in self.character_prompts if p['check_var'].get()]
                if active_chars:
                    for char_info in active_chars:
                        char_prompt = char_info['prompt_widget'].get(1.0, tk.END).strip()
                        char_uc = char_info['uc_widget'].get(1.0, tk.END).strip()
                        
                        char_v4_prompt = {'char_caption': char_prompt, 'centers': [{'x': 0.5, 'y': 0.5}]}
                        char_v4_uc = {'char_caption': char_uc, 'centers': [{'x': 0.5, 'y': 0.5}]}

                        data['parameters']['v4_prompt']['caption']['char_captions'].append(char_v4_prompt)
                        data['parameters']['v4_negative_prompt']['caption']['char_captions'].append(char_v4_uc)

            # 3. API 요청
            import requests
            response = requests.post(
                "https://image.novelai.net/ai/generate-image",
                headers={"Authorization": f"Bearer {access_token}"},
                json=data,
                timeout=180
            )
            response.raise_for_status()
            
            # 4. 이미지 처리
            image = self._process_nai_response(response.content)
            self.root.after(0, self._update_generation_result, image)

        except Exception as e:
            self.root.after(0, self._update_generation_result, e)

    def _process_nai_response(self, content):
        """NAI 응답(zip)을 처리하여 PIL Image 객체를 반환합니다."""
        import zipfile
        try:
            zipped = zipfile.ZipFile(io.BytesIO(content))
            image_bytes = zipped.read(zipped.infolist()[0])
            image = Image.open(io.BytesIO(image_bytes))
            return image
        except Exception as e:
            raise Exception(f"응답 데이터 처리 실패: {e}")

    def start_generation(self):
        # ... (기존 검증 로직) ...
        self.is_generating = True
        self.generation_start_time = time.time()
        self.generation_btn.config(state=tk.DISABLED)
        self.save_btn.config(state=tk.NORMAL) # <<<< 생성 시작 시 저장 버튼 활성화
        self.generation_image_label.config(image=None, text="🎨 이미지 생성 중...")
        self._update_timer()
        
        thread = threading.Thread(target=self._generation_thread)
        thread.daemon = True
        thread.start()

    def _update_generation_result(self, result):
        self.is_generating = False
        self.generation_btn.config(state=tk.NORMAL, text="Generation")

        if isinstance(result, Image.Image):
            self.last_generated_image = result # 원본 이미지 보관
            self.last_generated_image.save(self.temp_image_path, "PNG") # 임시 파일로 저장

            if self.auto_save_var.get():
                try:
                    save_dir = os.path.join("Output_WD14", self.save_session_folder)
                    os.makedirs(save_dir, exist_ok=True)
                    file_path = os.path.join(save_dir, f"{self.save_counter:05d}.png")
                    self.last_generated_image.save(file_path, "PNG")
                    self.save_counter += 1
                except Exception as e:
                    print(f"자동 저장 실패: {e}")

            thumbnail = self._create_thumbnail(result)
            photo = ImageTk.PhotoImage(thumbnail)
            self.generation_image_label.config(image=photo, text="")
            self.generation_image_label.image = photo
            
        elif isinstance(result, Exception):
            self.show_generation_preview()
            messagebox.showerror("생성 실패", f"이미지 생성 중 오류가 발생했습니다:\n{result}")

    def _show_image_with_pil(self):
        """PIL 라이브러리를 사용하여 마지막으로 생성된 이미지를 기본 이미지 뷰어로 엽니다."""
        if self.last_generated_image:
            try:
                self.last_generated_image.show()
            except Exception as e:
                messagebox.showerror("오류", f"이미지를 여는 중 오류가 발생했습니다: {e}")
        else:
            messagebox.showinfo("정보", "표시할 이미지가 없습니다.")

def main():
    try:
        from tkinterdnd2 import TkinterDnD
        root = TkinterDnD.Tk()
    except ImportError:
        print("tkinterdnd2가 설치되지 않아 Drag & Drop 기능이 비활성화됩니다.")
        root = tk.Tk()

    app = WD14TaggerGUI(root)
    root.mainloop()

if __name__ == "__main__":
    main()