settings_ui.py

import tkinter as tk
from tkinter import ttk, messagebox
import logging
from appearance import appearance_manager
from advance_ui import AdvanceUI
from settings import Settings, is_valid_hotkey


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 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.advance_ui = None
        self.hotkey_ui = None
        self.create_settings_window()

    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"""
        x = parent_x + parent_width + 20
        y = parent_y
        self.settings_window.geometry(f"+{x}+{y}")

        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"))

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

        if hasattr(self, "advance_button"):
            self.advance_button.config(text="Screen/API")
        if hasattr(self, "hotkey_button"):
            self.hotkey_button.config(text="HotKey")

    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 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 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()

                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 create_settings_ui(self):
        appearance_manager.create_styled_label(
            self.settings_window, text="Transparency:"
        ).pack(pady=5)
        # แก้ไขส่วนของ transparency_scale
        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)

        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()

        appearance_manager.create_styled_label(self.settings_window, text="Font:").pack(
            pady=5
        )
        thai_fonts = [
            "Fc Minimal",
            "Bai Jamjuree SemiBold",
            "PK Nakhon Sawan Regular Demo",
            "MaliThin",
            "Sarabun",
            "Noto Sans Thai Looped",
            "IBM Plex Sans Thai Medium",
        ]
        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)

        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)

        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)

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

        self.force_translate_var = tk.BooleanVar()
        self.auto_hide_var = tk.BooleanVar()
        self.ui_toggle_var = tk.BooleanVar()

        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)

        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 v3.1 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)

        self.advance_button = appearance_manager.create_styled_button(
            self.settings_window, "Screen/API", self.open_advance_ui
        )
        self.advance_button.pack(pady=16)

        self.hotkey_button = appearance_manager.create_styled_button(
            self.settings_window, "HotKey", self.toggle_hotkey_ui
        )
        self.hotkey_button.pack(pady=16)

        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)

        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 apply_settings(self, new_settings=None):
        """Apply settings with validation"""
        try:
            # กรณีกดปุ่ม Apply จาก settings UI
            if new_settings is None:
                try:
                    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()).strip()
                    width = max(100, min(2000, int(self.width_entry.get())))
                    height = max(100, min(1000, int(self.height_entry.get())))

                    enable_force = bool(self.force_translate_var.get())
                    enable_auto_hide = bool(self.auto_hide_var.get())
                    enable_ui_toggle = bool(self.ui_toggle_var.get())

                    settings_dict = {
                        "transparency": transparency,
                        "font_size": font_size,
                        "font": font,
                        "width": width,
                        "height": height,
                        "enable_force_translate": enable_force,
                        "enable_auto_hide": enable_auto_hide,
                        "enable_ui_toggle": enable_ui_toggle,
                    }

                    for key, value in settings_dict.items():
                        self.settings.set(key, value)

                    if self.apply_settings_callback:
                        self.apply_settings_callback(self.settings)
                        logging.info("Settings applied successfully")

                    return True, None

                except ValueError as e:
                    raise ValueError(f"Invalid input value: {str(e)}")

            # กรณีเรียกจาก advance settings
            else:
                logging.info("Applying advanced settings")
                if not isinstance(new_settings, dict):
                    raise ValueError("New settings must be a dictionary")

                old_model = self.settings.get("api_parameters", {}).get("model", "")
                new_model = new_settings.get("api_parameters", {}).get("model", "")

                if self.apply_settings_callback:
                    self.apply_settings_callback(new_settings)

                # Log model change
                if old_model != new_model:
                    print(f"\n=== API Model Changed ===")
                    print(f"Previous model: {old_model}")
                    print(f"New model: {new_model}")
                    print(f"Parameters: {self.settings.get_api_parameters()}")
                    print("=====================\n")
                    logging.info(f"API model changed from {old_model} to {new_model}")

                return True, None

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

    def open_advance_ui(self):
        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
            )
        self.advance_ui.open()

    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):
        if hasattr(self, "settings_x") and hasattr(self, "settings_y"):
            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}")