settings.py

import tkinter as tk
from tkinter import ttk, messagebox
import json
import os
import logging
from translator_factory import TranslatorFactory
from appearance import appearance_manager
from advance_ui import AdvanceUI


def is_valid_hotkey(hotkey):
    hotkey = hotkey.lower()
    valid_keys = set("abcdefghijklmnopqrstuvwxyz0123456789")
    valid_functions = set(
        ["f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12"]
    )
    valid_modifiers = set(["ctrl", "alt", "shift"])

    parts = hotkey.split("+")

    if len(parts) == 1:
        return parts[0] in valid_functions or parts[0] in valid_keys

    if len(parts) > 1:
        modifiers = parts[:-1]
        key = parts[-1]
        return all(mod in valid_modifiers for mod in modifiers) and (
            key in valid_keys or key in valid_functions
        )

    return False


class HotkeyUI:
    def __init__(self, parent, settings, update_hotkeys_callback):
        self.parent = parent
        self.settings = settings
        self.update_hotkeys_callback = update_hotkeys_callback
        self.hotkey_window = None
        self.toggle_ui_var = tk.StringVar()
        self.start_stop_var = tk.StringVar()

    def show(self):
        if self.hotkey_window is None or not self.hotkey_window.winfo_exists():
            self.create_hotkey_window()
        self.hotkey_window.deiconify()
        self.load_current_hotkeys()
        return self.hotkey_window

    def create_hotkey_window(self):
        self.hotkey_window = tk.Toplevel(self.parent)
        self.hotkey_window.title("Hotkey Settings")
        self.hotkey_window.geometry("240x240")
        self.hotkey_window.overrideredirect(True)
        self.hotkey_window.resizable(False, False)
        appearance_manager.apply_style(self.hotkey_window)

        tk.Label(
            self.hotkey_window,
            text="\n ตั้งค่าปุ่ม Hotkey\nที่ต้องการด้วยการ 'พิมพ์ตัวอักษร'\nแล้วกด save",
            bg=appearance_manager.bg_color,
            fg=appearance_manager.fg_color,
            justify=tk.LEFT,
        ).pack(pady=10, padx=10)

        toggle_frame = tk.Frame(self.hotkey_window, bg=appearance_manager.bg_color)
        toggle_frame.pack(fill=tk.X, padx=10, pady=5)
        tk.Label(
            toggle_frame,
            text="Toggle UI:",
            bg=appearance_manager.bg_color,
            fg=appearance_manager.fg_color,
        ).pack(side=tk.LEFT)
        self.toggle_ui_entry = tk.Entry(toggle_frame, textvariable=self.toggle_ui_var)
        self.toggle_ui_entry.pack(side=tk.RIGHT, expand=True, fill=tk.X)

        start_stop_frame = tk.Frame(self.hotkey_window, bg=appearance_manager.bg_color)
        start_stop_frame.pack(fill=tk.X, padx=10, pady=5)
        tk.Label(
            start_stop_frame,
            text="Start/Stop Translate:",
            bg=appearance_manager.bg_color,
            fg=appearance_manager.fg_color,
        ).pack(side=tk.LEFT)
        self.start_stop_entry = tk.Entry(
            start_stop_frame, textvariable=self.start_stop_var
        )
        self.start_stop_entry.pack(side=tk.RIGHT, expand=True, fill=tk.X)

        self.save_button = appearance_manager.create_styled_button(
            self.hotkey_window, "Save", self.save_hotkeys
        )
        self.save_button.pack(pady=10)

        close_button = appearance_manager.create_styled_button(
            self.hotkey_window, "X", self.close
        )
        close_button.place(x=5, y=5, width=20, height=20)

        self.hotkey_window.bind("<Button-1>", self.start_move)
        self.hotkey_window.bind("<ButtonRelease-1>", self.stop_move)
        self.hotkey_window.bind("<B1-Motion>", self.do_move)

    def load_current_hotkeys(self):
        self.toggle_ui_var.set(self.settings.get_shortcut("toggle_ui"))
        self.start_stop_var.set(self.settings.get_shortcut("start_stop_translate"))

    def save_hotkeys(self):
        toggle_ui = self.toggle_ui_var.get().lower()
        start_stop = self.start_stop_var.get().lower()

        if is_valid_hotkey(toggle_ui) and is_valid_hotkey(start_stop):
            self.settings.set_shortcut("toggle_ui", toggle_ui)
            self.settings.set_shortcut("start_stop_translate", start_stop)
            self.save_button.config(text="Saved!")
            print(
                f"New hotkeys saved: Toggle UI: {toggle_ui}, Start/Stop Translate: {start_stop}"
            )
            self.update_hotkeys_callback()
        else:
            messagebox.showerror("Invalid Hotkey", "Please enter valid hotkeys.")

    def close(self):
        if self.hotkey_window and self.hotkey_window.winfo_exists():
            self.save_button.config(text="Save")
            self.hotkey_window.withdraw()

    def start_move(self, event):
        self.x = event.x
        self.y = event.y

    def stop_move(self, event):
        self.x = None
        self.y = None

    def do_move(self, event):
        deltax = event.x - self.x
        deltay = event.y - self.y
        x = self.hotkey_window.winfo_x() + deltax
        y = self.hotkey_window.winfo_y() + deltay
        self.hotkey_window.geometry(f"+{x}+{y}")


class Settings:
    VALID_MODELS = {
        "gpt-4o": {"display_name": "gpt-4o", "type": "gpt"},
        "gpt-4o-mini": {"display_name": "gpt-4o-mini", "type": "gpt"},
        "claude-3-5-haiku-20241022": {
            "display_name": "claude-3.5-haiku",
            "type": "claude",
        },
    }

    DEFAULT_API_PARAMETERS = {
        # Main parameters for the model
        "model": "gpt-4o",
        "displayed_model": "gpt-4o",
        "max_tokens": 500,
        "temperature": 0.7,
        "top_p": 0.9,
        # Additional OCR settings for multiple languages
        "ocr_settings": {
            "languages": ["en", "ko"],
            "confidence_threshold": 0.65,
            "image_preprocessing": {
                "resize_factor": 2.0,
                "contrast": 1.5,
                "sharpness": 1.3,
                "threshold": 128,
            },
        },
        # Translation settings
        "translation_settings": {
            "source_languages": ["en", "ko"],
            "target_language": "th",
            "preserve_names": True,
            "modern_style": True,
            "flirty_tone": True,
            "use_emojis": True,
        },
        # Special characters handling
        "special_chars": {
            "korean_range": ["\u3130-\u318F", "\uAC00-\uD7AF"],
            "thai_range": ["\u0E00-\u0E7F"],
            "allowed_symbols": ["...", "—", "!", "?", "💕", "✨", "🥺", "😏"],
        },
    }

    def __init__(self):
        self.default_settings = {
            "api_parameters": self.DEFAULT_API_PARAMETERS.copy(),
            "transparency": 0.8,
            "font_size": 24,
            "font": "IBM Plex Sans Thai Medium.ttf",
            "width": 960,
            "height": 240,
            "enable_force_translate": True,
            "enable_auto_hide": True,
            "enable_ui_toggle": True,
            "bg_color": appearance_manager.bg_color,
            "translate_areas": {
                "A": {"start_x": 0, "start_y": 0, "end_x": 0, "end_y": 0},
                "B": {"start_x": 0, "start_y": 0, "end_x": 0, "end_y": 0},
                "C": {"start_x": 0, "start_y": 0, "end_x": 0, "end_y": 0},
            },
            "current_area": "A+B",
            "display_scale": None,
        }
        self.load_settings()
        self.ensure_default_values()

    def validate_model_parameters(self, params):
        """Validate the given parameters."""
        if not isinstance(params, dict):
            raise ValueError("Parameters must be a dictionary")

        # Check for valid model
        if "model" in params:
            if params["model"] not in self.VALID_MODELS:
                valid_models = list(self.VALID_MODELS.keys())
                raise ValueError(f"Invalid model. Must be one of: {valid_models}")

        # Validate numeric values
        if "max_tokens" in params:
            max_tokens = int(params["max_tokens"])
            if not (100 <= max_tokens <= 2000):
                raise ValueError("max_tokens must be between 100 and 2000")

        if "temperature" in params:
            temp = float(params["temperature"])
            if not (0.1 <= temp <= 1.0):
                raise ValueError("temperature must be between 0.1 and 1.0")

        return True

    def get_display_scale(self):
        """Return the stored display scale or None if not set."""
        return self.settings.get("display_scale")

    def set_display_scale(self, scale):
        """Save the display scale if valid."""
        try:
            scale = float(scale)
            if 0.5 <= scale <= 3.0:
                self.settings["display_scale"] = scale
                self.save_settings()
                print(f"Display scale saved: {int(scale * 100)}%")
                return True
            else:
                print(f"Invalid scale value: {scale}")
                return False
        except Exception as e:
            print(f"Error saving display scale: {e}")
            return False

    def validate_display_scale(self, scale):
        """Validate the display scale value."""
        try:
            scale = float(scale)
            if 0.5 <= scale <= 3.0:
                return {
                    "is_valid": True,
                    "message": "Valid scale value",
                    "value": scale,
                }
            return {
                "is_valid": False,
                "message": f"Scale must be between 50% and 300%, got {int(scale * 100)}%",
                "value": None,
            }
        except (ValueError, TypeError):
            return {
                "is_valid": False,
                "message": "Invalid scale value type",
                "value": None,
            }

    def set_bg_color(self, color):
        """Set and save the background color."""
        self.settings["bg_color"] = color
        self.save_settings()
        appearance_manager.update_bg_color(color)

    def get(self, key, default=None):
        if key == "bg_color":
            return self.settings.get("bg_color", appearance_manager.bg_color)
        return self.settings.get(key, default)

    def set(self, key, value):
        self.settings[key] = value
        self.save_settings()

    def load_settings(self):
        try:
            with open("settings.json", "r") as f:
                self.settings = json.load(f)
        except FileNotFoundError:
            self.settings = {
                "transparency": 0.8,
                "font_size": 24,
                "font": "IBM Plex Sans Thai Medium.ttf",
                "width": 960,
                "height": 240,
                "enable_force_translate": True,
                "enable_auto_hide": True,
                "enable_ui_toggle": True,
                "translate_areas": {
                    "A": {"start_x": 0, "start_y": 0, "end_x": 0, "end_y": 0},
                    "B": {"start_x": 0, "start_y": 0, "end_x": 0, "end_y": 0},
                    "C": {"start_x": 0, "start_y": 0, "end_x": 0, "end_y": 0},
                },
                "api_parameters": {
                    "model": "gpt-4o",
                    "max_tokens": 500,
                    "temperature": 0.7,
                    "top_p": 0.9,
                },
                "use_gpu_for_ocr": False,
                "shortcuts": {"toggle_ui": "alt+h", "start_stop_translate": "f9"},
                "logs_ui": {
                    "width": 480,
                    "height": 320,
                    "font_size": 16,
                    "visible": True,
                },
            }

    def save_settings(self):
        """Save all current settings to file."""
        try:
            # จัดการ API parameters
            if "api_parameters" in self.settings:
                api_params = self.settings["api_parameters"]
                if api_params.get("model") == "claude-3-5-haiku-20241022":
                    api_params.pop("top_p", None)
                if "temperature" in api_params:
                    api_params["temperature"] = (
                        round(api_params["temperature"] * 10) / 10
                    )
                if "top_p" in api_params:
                    api_params["top_p"] = round(api_params["top_p"] * 10) / 10

            # จัดการ current_area
            if "current_area" in self.settings:
                current_areas = self.settings["current_area"]
                if isinstance(current_areas, list):
                    self.settings["current_area"] = "+".join(current_areas)

            # ตรวจสอบและจัดการ area_presets
            if "area_presets" not in self.settings:
                self.settings["area_presets"] = [
                    {"name": "Preset 1", "areas": "A+B"},
                    {"name": "Preset 2", "areas": "C"},
                    {"name": "Preset 3", "areas": "A"},
                    {"name": "Preset 4", "areas": "B"},
                    {"name": "Preset 5", "areas": "A+B+C"},
                ]

            # บันทึกไฟล์
            with open("settings.json", "w") as f:
                json.dump(self.settings, f, indent=4)

        except Exception as e:
            logging.error(f"Error saving settings: {e}")
            raise

    def ensure_default_values(self):
        """Add default values if missing."""
        if "bg_color" not in self.settings:
            self.settings["bg_color"] = appearance_manager.bg_color
        if "api_parameters" not in self.settings:
            self.settings["api_parameters"] = self.DEFAULT_API_PARAMETERS.copy()
        if "display_scale" not in self.settings:
            self.settings["display_scale"] = None
        if "area_presets" not in self.settings:
            # เพิ่ม default presets
            self.settings["area_presets"] = [
                {"name": "Preset 1", "areas": "A+B"},  # Default preset 1
                {"name": "Preset 2", "areas": "C"},  # Default preset 2
                {"name": "Preset 3", "areas": "A"},  # Default preset 3
                {"name": "Preset 4", "areas": "B"},  # Default preset 4
                {"name": "Preset 5", "areas": "A+B+C"},  # Default preset 5
            ]

        # ตรวจสอบและอัพเดท API parameters
        current_params = self.settings.get("api_parameters", {})
        for key, value in self.DEFAULT_API_PARAMETERS.items():
            if key not in current_params:
                current_params[key] = value

        if "model" in current_params:
            if current_params["model"] == "claude-3-5-haiku-20241022":
                current_params.pop("top_p", None)
            if "displayed_model" not in current_params:
                current_params["displayed_model"] = self.VALID_MODELS.get(
                    current_params["model"], {}
                ).get("display_name", current_params["model"])

        self.save_settings()

    def get_preset(self, preset_number):
        """รับค่า preset ตามหมายเลข"""
        presets = self.settings.get("area_presets", [])
        if 1 <= preset_number <= len(presets):
            return presets[preset_number - 1]
        return None

    def validate_coordinates(self, coordinates):
        """ตรวจสอบความถูกต้องของพิกัดสำหรับแต่ละพื้นที่
        Args:
            coordinates (dict): Dictionary ของพิกัดแต่ละพื้นที่
                เช่น: {
                    'A': {'start_x': 100, 'start_y': 100, 'end_x': 200, 'end_y': 200},
                    'B': {'start_x': 300, 'start_y': 300, 'end_x': 400, 'end_y': 400}
                }
        Returns:
            bool: True ถ้าพิกัดถูกต้อง, False ถ้าไม่ถูกต้อง
        """
        required_keys = {"start_x", "start_y", "end_x", "end_y"}

        try:
            for area, coords in coordinates.items():
                # ตรวจสอบว่ามี key ครบทุกตัว
                if not all(key in coords for key in required_keys):
                    logging.error(f"Missing required coordinate keys for area {area}")
                    return False

                # ตรวจสอบว่าค่าพิกัดเป็นตัวเลขทั้งหมด
                if not all(
                    isinstance(coords[key], (int, float)) for key in required_keys
                ):
                    logging.error(f"Invalid coordinate values for area {area}")
                    return False

                # ตรวจสอบว่าค่าพิกัดมีความสมเหตุสมผล
                if (
                    coords["end_x"] <= coords["start_x"]
                    or coords["end_y"] <= coords["start_y"]
                ):
                    logging.error(f"Invalid coordinate ranges for area {area}")
                    return False

                # ตรวจสอบว่าค่าพิกัดไม่ติดลบ
                if any(coords[key] < 0 for key in required_keys):
                    logging.error(f"Negative coordinates found for area {area}")
                    return False

            return True

        except Exception as e:
            logging.error(f"Error validating coordinates: {e}")
            return False

    def save_preset(self, preset_number, areas, coordinates):
        """บันทึก preset พร้อมพิกัด
        Args:
            preset_number: หมายเลข preset (1-5)
            areas: สตริงของพื้นที่ เช่น "A+B"
            coordinates: dict ของพิกัดแต่ละพื้นที่
        """
        try:
            # ตรวจสอบความถูกต้องของพิกัด
            if not self.validate_coordinates(coordinates):
                raise ValueError("Invalid coordinates provided")

            # ดึงข้อมูล presets ทั้งหมด
            presets = self.settings.get("area_presets", [])

            # สร้างข้อมูล preset ใหม่
            preset_data = {
                "name": f"Preset {preset_number}",
                "areas": areas,
                "coordinates": coordinates,
            }

            # อัพเดต preset ในตำแหน่งที่กำหนด
            index = preset_number - 1
            if 0 <= index < len(presets):
                presets[index] = preset_data
            else:
                # เพิ่ม preset ใหม่ถ้าไม่มีในตำแหน่งที่ต้องการ
                while len(presets) <= index:
                    presets.append(
                        {
                            "name": f"Preset {len(presets) + 1}",
                            "areas": "A+B",
                            "coordinates": {},
                        }
                    )
                presets[index] = preset_data

            # บันทึกลงไฟล์
            self.settings["area_presets"] = presets
            self.save_settings()

            logging.info(f"Saved preset {preset_number} with areas: {areas}")

        except Exception as e:
            logging.error(f"Error saving preset: {e}")
            raise

    def get_all_presets(self):
        """รับค่า presets ทั้งหมด"""
        return self.settings.get("area_presets", [])

    def validate_preset(self, preset_number, preset_data):
        """ตรวจสอบความถูกต้องของข้อมูล preset
        Args:
            preset_number: หมายเลข preset (1-5)
            preset_data: ข้อมูล preset ที่จะบันทึก
        Returns:
            bool: True ถ้าข้อมูลถูกต้อง
        """
        try:
            if not 1 <= preset_number <= 5:
                return False

            if not isinstance(preset_data, dict):
                return False

            required_keys = {"name", "areas", "coordinates"}
            if not all(key in preset_data for key in required_keys):
                return False

            # ตรวจสอบพื้นที่
            areas = preset_data["areas"].split("+")
            if not all(area in ["A", "B", "C"] for area in areas):
                return False

            # ตรวจสอบพิกัด
            if not self.validate_coordinates(preset_data["coordinates"]):
                return False

            return True

        except Exception as e:
            logging.error(f"Error validating preset: {e}")
            return False

    def set_current_preset(self, preset_number):
        """ตั้งค่า preset ปัจจุบัน
        Args:
            preset_number: int ระหว่าง 1-5
        """
        if not 1 <= preset_number <= 5:
            raise ValueError("Invalid preset number")
        self.settings["current_preset"] = preset_number
        self.save_settings()

    def get_current_preset(self):
        """รับค่า preset ปัจจุบัน
        Returns:
            int: หมายเลข preset ปัจจุบัน (1-5)
        """
        return self.settings.get("current_preset", 1)

    def get_logs_settings(self):
        """Return the settings for the logs UI."""
        return self.settings.get(
            "logs_ui", {"width": 480, "height": 320, "font_size": 16, "visible": True}
        )

    def set_logs_settings(self, width=None, height=None, font_size=None, visible=None):
        """Update the logs UI settings."""
        if "logs_ui" not in self.settings:
            self.settings["logs_ui"] = {}

        if width is not None:
            self.settings["logs_ui"]["width"] = width
        if height is not None:
            self.settings["logs_ui"]["height"] = height
        if font_size is not None:
            self.settings["logs_ui"]["font_size"] = font_size
        if visible is not None:
            self.settings["logs_ui"]["visible"] = visible

        self.save_settings()

    def get_shortcut(self, action, default=None):
        return self.settings.get("shortcuts", {}).get(action, default)

    def set_shortcut(self, action, shortcut):
        if "shortcuts" not in self.settings:
            self.settings["shortcuts"] = {}
        self.settings["shortcuts"][action] = shortcut
        self.save_settings()

    def set_screen_size(self, size):
        self.settings["screen_size"] = size
        self.save_settings()

    def set_gpu_for_ocr(self, use_gpu):
        self.settings["use_gpu_for_ocr"] = use_gpu
        self.save_settings()
        current_mode = "GPU" if use_gpu else "CPU"
        logging.info(f"Switched OCR to [{current_mode}]")
        print(f"Switched OCR to [{current_mode}]")

    def set_current_area(self, area):
        self.settings["current_area"] = area
        self.save_settings()

    def get_current_area(self):
        return self.settings.get("current_area", "A")

    def set_translate_area(self, start_x, start_y, end_x, end_y, area):
        """Save the translation area without brush points."""
        self.settings["translate_areas"] = self.settings.get("translate_areas", {})
        self.settings["translate_areas"][area] = {
            "start_x": start_x,
            "start_y": start_y,
            "end_x": end_x,
            "end_y": end_y,
        }
        self.save_settings()

    def get_translate_area(self, area):
        """Return the translation area data."""
        translate_areas = self.settings.get("translate_areas", {})
        return translate_areas.get(area, None)

    def set_api_parameters(
        self, model=None, max_tokens=None, temperature=None, top_p=None
    ):
        try:
            if "api_parameters" not in self.settings:
                self.settings["api_parameters"] = {}

            api_params = self.settings["api_parameters"]
            changes = []

            if model is not None:
                if model not in self.VALID_MODELS:
                    raise ValueError(f"Invalid model: {model}")
                old_model = api_params.get("model")
                model_info = self.VALID_MODELS[model]
                api_params.update(
                    {"model": model, "displayed_model": model_info["display_name"]}
                )
                if model_info["type"] == "claude":
                    api_params.pop("top_p", None)
                changes.append(f"Model: {old_model} -> {model}")

            if max_tokens is not None:
                if not (100 <= max_tokens <= 1000):
                    raise ValueError("Max tokens must be between 100 and 1000")
                old_tokens = api_params.get("max_tokens")
                api_params["max_tokens"] = max_tokens
                changes.append(f"Max tokens: {old_tokens} -> {max_tokens}")

            if temperature is not None:
                if not (0.1 <= temperature <= 0.9):
                    raise ValueError("Temperature must be between 0.1 and 0.9")
                old_temp = api_params.get("temperature")
                api_params["temperature"] = round(temperature * 10) / 10
                changes.append(f"Temperature: {old_temp} -> {temperature}")

            if (
                self.VALID_MODELS.get(model or api_params.get("model", ""), {}).get(
                    "type"
                )
                == "gpt"
            ):
                if top_p is not None:
                    if not (0.1 <= top_p <= 0.9):
                        raise ValueError("Top P must be between 0.1 and 0.9")
                    old_top_p = api_params.get("top_p")
                    api_params["top_p"] = round(top_p * 10) / 10
                    changes.append(f"Top P: {old_top_p} -> {top_p}")

            self.save_settings()

            if changes:
                logging.info("\n=== API Parameters Updated ===")
                for change in changes:
                    logging.info(change)
                logging.info(f"Current Settings: {api_params}")
                logging.info("============================\n")

            return True, None
        except Exception as e:
            logging.error(f"Error setting API parameters: {str(e)}")
            return False, str(e)

    def get_displayed_model(self):
        """Return the model name for UI display."""
        api_params = self.get_api_parameters()
        return api_params.get("displayed_model", api_params.get("model", "gpt-4o"))

    def get_api_parameters(self):
        """Return the current API parameters."""
        default_params = {
            "model": "gpt-4o",
            "displayed_model": "gpt-4o",
            "max_tokens": 500,
            "temperature": 0.7,
            "top_p": 0.9,
        }
        params = self.settings.get("api_parameters", default_params).copy()

        if params.get("model") == "claude-3-5-haiku-20241022":
            params["displayed_model"] = "claude-3.5-haiku"
            params.pop("top_p", None)

        if "temperature" in params:
            params["temperature"] = round(params["temperature"] * 10) / 10
        if "top_p" in params:
            params["top_p"] = round(params["top_p"] * 10) / 10

        return params


class SettingsUI:
    def __init__(
        self, parent, settings, apply_settings_callback, update_hotkeys_callback
    ):
        self.parent = parent
        self.settings = settings
        self.apply_settings_callback = apply_settings_callback
        self.update_hotkeys_callback = update_hotkeys_callback
        self.settings_window = None
        self.settings_visible = False
        self.ocr_toggle_callback = None
        self.create_settings_window()
        self.advance_ui = None
        self.hotkey_ui = None

    def create_settings_window(self):
        self.settings_window = tk.Toplevel(self.parent)
        self.settings_window.overrideredirect(True)
        appearance_manager.apply_style(self.settings_window)
        self.create_settings_ui()
        self.settings_window.withdraw()

    def set_ocr_toggle_callback(self, callback):
        self.ocr_toggle_callback = callback
        if self.advance_ui:
            self.advance_ui.settings_ui.ocr_toggle_callback = callback

    def open_settings(self, parent_x, parent_y, parent_width):
        """Open settings window at specified position relative to parent"""
        # Calculate position for settings window
        x = parent_x + parent_width + 20
        y = parent_y
        self.settings_window.geometry(f"+{x}+{y}")

        # Load current settings into UI
        self.transparency_scale.set(int(self.settings.get("transparency") * 100))
        self.font_size_var.set(str(self.settings.get("font_size")))
        self.font_var.set(self.settings.get("font"))
        self.width_entry.delete(0, tk.END)
        self.width_entry.insert(0, str(self.settings.get("width")))
        self.height_entry.delete(0, tk.END)
        self.height_entry.insert(0, str(self.settings.get("height")))
        self.force_translate_var.set(self.settings.get("enable_force_translate"))
        self.auto_hide_var.set(self.settings.get("enable_auto_hide"))
        self.ui_toggle_var.set(self.settings.get("enable_ui_toggle"))

        # Show window
        self.settings_window.deiconify()
        self.settings_window.lift()
        self.settings_window.attributes("-topmost", True)
        self.settings_visible = True

        # Reset button texts if needed
        if hasattr(self, "advance_button"):
            self.advance_button.config(text="Screen/API")
        if hasattr(self, "hotkey_button"):
            self.hotkey_button.config(text="HotKey")

    def open(self):
        """Toggle the advance window visibility"""
        if self.advance_window is None or not self.advance_window.winfo_exists():
            self.create_advance_window()

        if self.advance_window.winfo_viewable():
            self.close()  # ถ้ากำลังแสดงอยู่ให้ซ่อน
            if hasattr(self.parent, "advance_button"):
                self.parent.advance_button.config(text="Screen/API")
        else:
            # คำนวณตำแหน่งให้อยู่ทางขวาของ settings ui โดยเว้นระยะ 5px
            parent_x = self.parent.winfo_x()
            parent_y = self.parent.winfo_y()
            parent_width = self.parent.winfo_width()

            # กำหนดตำแหน่งใหม่
            x = parent_x + parent_width + 5  # เว้นระยะห่าง 5px
            y = parent_y  # ให้อยู่ระดับเดียวกับ settings ui

            self.advance_window.geometry(f"+{x}+{y}")
            self.advance_window.deiconify()
            self.advance_window.lift()  # ยกให้อยู่บนสุด
            self.advance_window.attributes("-topmost", True)

            self.load_current_settings()
            self.is_changed = False
            self.update_save_button()

            if hasattr(self.parent, "advance_button"):
                self.parent.advance_button.config(text="Close Advanced")

    def close_settings(self):
        self.settings_window.withdraw()
        self.settings_visible = False
        if self.advance_ui:
            self.advance_ui.close()
        if self.hotkey_ui:
            self.hotkey_ui.close()
        self.hotkey_button.config(text="HotKey")  # รีเซ็ตข้อความบนปุ่ม

    def validate_window_size(self, event=None):
        """Validate and update window size from entries"""
        try:
            width = int(self.width_entry.get())
            height = int(self.height_entry.get())

            # กำหนดขนาดขั้นต่ำ-สูงสุด
            width = max(300, min(2000, width))
            height = max(200, min(1000, height))

            # Update entries with validated values
            self.width_entry.delete(0, tk.END)
            self.width_entry.insert(0, str(width))
            self.height_entry.delete(0, tk.END)
            self.height_entry.insert(0, str(height))

            # Save to settings
            self.settings.set("width", width)
            self.settings.set("height", height)

            return True

        except ValueError:
            messagebox.showerror(
                "Invalid Input", "Please enter valid numbers for width and height"
            )

            # Reset to current settings values
            self.width_entry.delete(0, tk.END)
            self.width_entry.insert(0, str(self.settings.get("width")))
            self.height_entry.delete(0, tk.END)
            self.height_entry.insert(0, str(self.settings.get("height")))

            return False

    def create_settings_ui(self):
        # Transparency
        appearance_manager.create_styled_label(
            self.settings_window, text="Transparency:"
        ).pack(pady=5)
        transparency_frame, self.transparency_scale = (
            appearance_manager.create_styled_scale(
                self.settings_window, from_=0, to=100, orient=tk.HORIZONTAL
            )
        )
        transparency_frame.pack(pady=5, padx=10, fill=tk.X)

        # Font Size
        appearance_manager.create_styled_label(
            self.settings_window, text="Font Size:"
        ).pack(pady=5)
        font_sizes = [16, 20, 24, 28, 32, 36]
        self.font_size_var = tk.StringVar()
        self.font_size_dropdown = appearance_manager.create_styled_combobox(
            self.settings_window, values=font_sizes, textvariable=self.font_size_var
        )
        self.font_size_dropdown.pack(pady=5, padx=10, fill=tk.X)

        self.transparency_value = self.transparency_scale.get()

        # Font Selection
        appearance_manager.create_styled_label(self.settings_window, text="Font:").pack(
            pady=5
        )
        thai_fonts = [
            "FC Minimal",
            "Nicalization Rg",
            "แบบบริการ TrueType",
            "Bai Jamjuree Light",
            "Bai Jamjuree Regular",
            "Bai Jamjuree SemiBold",
            "FC Minimal Medium",
            "IBM Plex Sans Thai Medium",
            "JetBrains Mono NL Bold",
            "JetBrains Mono NL Light",
            "JetBrains MonoNL Light Italic",
            "MaliThin",
            "Noto Sans Thai Looped Light",
            "Noto Sans Thai Looped",
            "PK Nakhon Sawan Regular Demo",
            "Sarabun",
        ]

        self.font_var = tk.StringVar()
        self.font_dropdown = appearance_manager.create_styled_combobox(
            self.settings_window, values=thai_fonts, textvariable=self.font_var
        )
        self.font_dropdown.pack(pady=5, padx=10, fill=tk.X)

        # เพิ่ม callback เมื่อมีการเปลี่ยนฟอนต์
        def on_font_change(*args):
            font_name = self.font_var.get()
            is_italic = "Italic" in font_name
            font_style = "italic" if is_italic else "roman"
            current_size = self.settings.get("font_size", 24)

            # อัพเดทการตั้งค่าฟอนต์
            self.settings.set("font", font_name)
            self.settings.set("font_style", font_style)

            # อัพเดท UI ทันที
            if hasattr(self, "translated_ui") and self.translated_ui:
                self.translated_ui.canvas.itemconfig(
                    self.translated_ui.text_container,
                    font=(font_name, current_size),
                    slant=font_style,
                )

                # อัพเดท outlines
                if hasattr(self.translated_ui, "outline_container"):
                    for outline in self.translated_ui.outline_container:
                        self.translated_ui.canvas.itemconfig(
                            outline, font=(font_name, current_size), slant=font_style
                        )

        self.font_var.trace_add("write", on_font_change)

        # Window Size
        appearance_manager.create_styled_label(
            self.settings_window, text="Window Width (px):"
        ).pack(pady=5)
        self.width_entry = tk.Entry(self.settings_window, width=10)
        self.width_entry.pack(pady=5, padx=10, fill=tk.X)
        self.width_entry.bind("<FocusOut>", self.validate_window_size)
        self.width_entry.bind("<Return>", self.validate_window_size)

        appearance_manager.create_styled_label(
            self.settings_window, text="Window Height (px):"
        ).pack(pady=5)
        self.height_entry = tk.Entry(self.settings_window, width=10)
        self.height_entry.pack(pady=5, padx=10, fill=tk.X)
        self.height_entry.bind("<FocusOut>", self.validate_window_size)
        self.height_entry.bind("<Return>", self.validate_window_size)

        # Apply Button
        apply_button = appearance_manager.create_styled_button(
            self.settings_window, "Apply", self.apply_settings
        )
        apply_button.pack(pady=20)

        # Toggle Variables
        self.force_translate_var = tk.BooleanVar()
        self.auto_hide_var = tk.BooleanVar()
        self.ui_toggle_var = tk.BooleanVar()

        # Toggle Switches
        self.create_toggle_switch(
            "Enable 'R-click' to Force Translate", self.force_translate_var
        )
        self.create_toggle_switch("Enable Auto-hide on Movement", self.auto_hide_var)
        self.create_toggle_switch("Enable UI Toggle", self.ui_toggle_var)

        # Button Container
        button_container = tk.Frame(
            self.settings_window, bg=appearance_manager.bg_color
        )
        button_container.pack(pady=10)

        # Screen/CPU Settings Button
        self.display_button = appearance_manager.create_styled_button(
            button_container, "Screen/CPU", self.toggle_advance_ui, hover_bg="#404040"
        )
        self.display_button.pack(side=tk.LEFT, padx=5)

        # Model Settings Button
        self.model_button = appearance_manager.create_styled_button(
            button_container, "Model", self.toggle_model_settings, hover_bg="#404040"
        )
        self.model_button.pack(side=tk.LEFT, padx=5)

        # Hotkey Button
        self.hotkey_button = appearance_manager.create_styled_button(
            button_container, "HotKey", self.toggle_hotkey_ui, hover_bg="#404040"
        )
        self.hotkey_button.pack(side=tk.LEFT, padx=5)

        # Bottom Labels
        self.shortcut_label = tk.Label(
            self.settings_window,
            text="Shortcuts:\nALT+H: Toggle UI\nF9: Start/Stop Translation",
            bg=appearance_manager.bg_color,
            fg=appearance_manager.fg_color,
            font=("IBM Plex Sans Thai Medium", 8, "bold"),
            justify=tk.LEFT,
        )
        self.shortcut_label.pack(side=tk.BOTTOM, pady=10)

        self.credit_label = tk.Label(
            self.settings_window,
            text="Magicite-Babel v5.0 beta, \nDeveloped by iarcanar",
            bg=appearance_manager.bg_color,
            fg=appearance_manager.fg_color,
            font=("IBM Plex Sans Thai Medium", 10, "normal"),
            justify=tk.CENTER,
        )
        self.credit_label.pack(side=tk.BOTTOM, pady=5)

        # Close Button
        close_button = appearance_manager.create_styled_button(
            self.settings_window, "X", self.close_settings
        )
        close_button.place(x=5, y=5, width=20, height=20)

        # Window Movement Bindings
        self.settings_window.bind("<Button-1>", self.start_move_settings)
        self.settings_window.bind("<ButtonRelease-1>", self.stop_move_settings)
        self.settings_window.bind("<B1-Motion>", self.do_move_settings)

    def toggle_advance_ui(self):
        """Toggle Advanced UI window"""
        if (
            self.advance_ui is None
            or not hasattr(self.advance_ui, "advance_window")
            or not self.advance_ui.advance_window.winfo_exists()
        ):
            self.advance_ui = AdvanceUI(
                self.settings_window,
                self.settings,
                self.apply_settings_callback,
                self.ocr_toggle_callback,
            )

        if self.advance_ui.advance_window.winfo_viewable():
            self.advance_ui.close()
            self.display_button.config(text="Screen/CPU")
        else:
            self.advance_ui.open()
            self.display_button.config(text="Close Screen")

    def toggle_model_settings(self):
        """Toggle Model Settings window"""
        if not hasattr(self, "model_settings"):
            from model import ModelSettings

            self.model_settings = ModelSettings(
                self.settings_window, self.settings, self.apply_settings_callback
            )

        if (
            self.model_settings.model_window
            and self.model_settings.model_window.winfo_exists()
            and self.model_settings.model_window.winfo_viewable()
        ):
            self.model_settings.close()
            self.model_button.config(text="Model")
        else:
            self.model_settings.open()
            self.model_button.config(text="Close Model")

    def toggle_hotkey_ui(self):
        if self.hotkey_ui is None:
            self.hotkey_ui = HotkeyUI(
                self.settings_window, self.settings, self.update_hotkeys_callback
            )

        if (
            self.hotkey_ui.hotkey_window
            and self.hotkey_ui.hotkey_window.winfo_viewable()
        ):
            self.hotkey_ui.close()
            self.hotkey_button.config(text="HotKey")
        else:
            hotkey_window = self.hotkey_ui.show()
            if hotkey_window:
                settings_x = self.settings_window.winfo_x()
                settings_y = self.settings_window.winfo_y()
                settings_height = self.settings_window.winfo_height()

                # ใช้ update_idletasks เพื่อให้แน่ใจว่า geometry ได้รับการอัพเดตแล้ว
                hotkey_window.update_idletasks()

                hotkey_x = settings_x - hotkey_window.winfo_width() - 5
                hotkey_y = settings_y + settings_height - hotkey_window.winfo_height()

                hotkey_window.geometry(f"+{hotkey_x}+{hotkey_y}")
            self.hotkey_button.config(text="Close m.Hotkeys")

    def open_hotkey_ui(self):
        if self.hotkey_ui is None:
            self.hotkey_ui = HotkeyUI(
                self.settings_window, self.settings, self.update_hotkeys_callback
            )

        settings_x = self.settings_window.winfo_x()
        settings_y = self.settings_window.winfo_y()
        settings_height = self.settings_window.winfo_height()

        hotkey_x = settings_x
        hotkey_y = settings_y + settings_height + 5

        hotkey_window = self.hotkey_ui.show()
        if hotkey_window:
            hotkey_window.geometry(f"+{hotkey_x}+{hotkey_y}")

    def create_toggle_switch(self, text, variable):
        frame = tk.Frame(self.settings_window, bg=appearance_manager.bg_color)
        frame.pack(pady=5, padx=10, fill=tk.X)

        label = tk.Label(
            frame,
            text=text,
            bg=appearance_manager.bg_color,
            fg=appearance_manager.fg_color,
        )
        label.pack(side=tk.LEFT)

        switch = ttk.Checkbutton(frame, style="Switch.TCheckbutton", variable=variable)
        switch.pack(side=tk.RIGHT)

    def apply_settings(self, settings_dict=None):
        try:
            if settings_dict is None:
                # กรณีกดปุ่ม Apply จาก settings UI
                settings_dict = {
                    "transparency": max(
                        0.1, min(1.0, float(self.transparency_scale.get()) / 100)
                    ),
                    "font_size": int(self.font_size_var.get()),
                    "font": str(self.font_var.get()),
                    "font_style": (
                        "italic" if "Italic" in self.font_var.get() else "roman"
                    ),
                    "width": max(300, min(2000, int(self.width_entry.get()))),
                    "height": max(200, min(1000, int(self.height_entry.get()))),
                    "enable_force_translate": bool(self.force_translate_var.get()),
                    "enable_auto_hide": bool(self.auto_hide_var.get()),
                    "enable_ui_toggle": bool(self.ui_toggle_var.get()),
                }

            # อัพเดทการตั้งค่า
            for key, value in settings_dict.items():
                if key != "font_style":  # font_style จะถูกจัดการพร้อมกับ font
                    self.settings.set(key, value)

            # อัพเดท UI components
            if hasattr(self, "translated_ui") and self.translated_ui:
                if "transparency" in settings_dict:
                    self.translated_ui.update_transparency(
                        settings_dict["transparency"]
                    )
                if "font_size" in settings_dict:
                    font_name = settings_dict.get("font", self.settings.get("font"))
                    font_style = settings_dict.get("font_style", "roman")
                    self.translated_ui.canvas.itemconfig(
                        self.translated_ui.text_container,
                        font=(font_name, settings_dict["font_size"]),
                        slant=font_style,
                    )
                if "font" in settings_dict:
                    font_size = self.settings.get("font_size", 24)
                    font_style = settings_dict.get("font_style", "roman")
                    self.translated_ui.canvas.itemconfig(
                        self.translated_ui.text_container,
                        font=(settings_dict["font"], font_size),
                        slant=font_style,
                    )

                # อัพเดท outlines ถ้ามี
                if hasattr(self.translated_ui, "outline_container"):
                    for outline in self.translated_ui.outline_container:
                        if "font" in settings_dict or "font_size" in settings_dict:
                            font_name = settings_dict.get(
                                "font", self.settings.get("font")
                            )
                            font_size = settings_dict.get(
                                "font_size", self.settings.get("font_size")
                            )
                            font_style = settings_dict.get("font_style", "roman")
                            self.translated_ui.canvas.itemconfig(
                                outline, font=(font_name, font_size), slant=font_style
                            )

            # เรียก callback ถ้ามี
            if self.apply_settings_callback:
                self.apply_settings_callback(settings_dict)

            return True

        except Exception as e:
            error_msg = f"Error applying settings: {e}"
            logging.error(error_msg)
            messagebox.showerror("Error", error_msg)
            return False

    def start_move_settings(self, event):
        self.settings_x = event.x
        self.settings_y = event.y

    def stop_move_settings(self, event):
        self.settings_x = None
        self.settings_y = None

    def do_move_settings(self, event):
        deltax = event.x - self.settings_x
        deltay = event.y - self.settings_y
        x = self.settings_window.winfo_x() + deltax
        y = self.settings_window.winfo_y() + deltay
        self.settings_window.geometry(f"+{x}+{y}")

        if (
            self.hotkey_ui
            and self.hotkey_ui.hotkey_window
            and self.hotkey_ui.hotkey_window.winfo_exists()
        ):
            hotkey_window = self.hotkey_ui.hotkey_window
            hotkey_window.update_idletasks()
            settings_height = self.settings_window.winfo_height()
            hotkey_x = x - hotkey_window.winfo_width() - 5
            hotkey_y = y + settings_height - hotkey_window.winfo_height()
            hotkey_window.geometry(f"+{hotkey_x}+{hotkey_y}")

    def open_advance_ui(self):
        # สร้าง advance_ui ใหม่ถ้ายังไม่มีหรือถูกปิดไป
        if (
            self.advance_ui is None
            or not hasattr(self.advance_ui, "advance_window")
            or not self.advance_ui.advance_window.winfo_exists()
        ):
            self.advance_ui = AdvanceUI(
                self.settings_window, self.settings, self.apply_settings_callback, None
            )

        # เปิดหน้าต่าง advance_ui
        self.advance_ui.open()