model.py

import tkinter as tk
from tkinter import ttk, messagebox
import logging
from appearance import appearance_manager


class ModelSettings:
    def __init__(self, parent, settings, apply_settings_callback):
        self.parent = parent
        self.settings = settings
        self.apply_settings_callback = apply_settings_callback
        self.model_window = None
        self.window_created = False

    def create_model_window(self):
        if self.model_window is None or not self.model_window.winfo_exists():
            self.model_window = tk.Toplevel(self.parent)
            self.model_window.title("API Model Settings")
            self.model_window.geometry("480x400")  # กว้างขึ้นเพื่อรองรับ 2 columns
            self.model_window.overrideredirect(True)
            appearance_manager.apply_style(self.model_window)

            # Main Container
            main_container = tk.Frame(self.model_window, bg=appearance_manager.bg_color)
            main_container.pack(expand=True, fill=tk.BOTH, padx=10, pady=5)

            # Model Selection Frame (Top)
            model_frame = tk.Frame(main_container, bg=appearance_manager.bg_color)
            model_frame.pack(fill=tk.X, pady=10)

            appearance_manager.create_styled_label(
                model_frame, text="Select Model:"
            ).pack(side=tk.LEFT, padx=5)

            # Model Dropdown
            self.model_var = tk.StringVar()
            model_options = ["gpt-4o", "gpt-4o-mini", "claude-3.5-haiku"]
            self.model_combo = appearance_manager.create_styled_combobox(
                model_frame, values=model_options, textvariable=self.model_var, width=15
            )
            self.model_combo.pack(side=tk.LEFT, padx=5)
            self.model_combo.bind("<<ComboboxSelected>>", self.on_model_change)

            # Parameters Container (Left and Right panels)
            params_container = tk.Frame(main_container, bg=appearance_manager.bg_color)
            params_container.pack(expand=True, fill=tk.BOTH, pady=10)

            # GPT Parameters (Left)
            self.gpt_frame = tk.LabelFrame(
                params_container,
                text="GPT Parameters",
                bg=appearance_manager.bg_color,
                fg="white",
            )
            self.gpt_frame.pack(side=tk.LEFT, expand=True, fill=tk.BOTH, padx=5)

            # Claude Parameters (Right)
            self.claude_frame = tk.LabelFrame(
                params_container,
                text="Claude Parameters",
                bg=appearance_manager.bg_color,
                fg="white",
            )
            self.claude_frame.pack(side=tk.RIGHT, expand=True, fill=tk.BOTH, padx=5)

            # Create parameters for both models
            self.create_gpt_parameters()
            self.create_claude_parameters()

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

            # Close button
            close_button = appearance_manager.create_styled_button(
                self.model_window, "X", self.close
            )
            close_button.place(x=5, y=5, width=20, height=20)

            # Window movement
            self.model_window.bind("<Button-1>", self.start_move)
            self.model_window.bind("<ButtonRelease-1>", self.stop_move)
            self.model_window.bind("<B1-Motion>", self.do_move)

            self.window_created = True
            self.model_window.withdraw()

            # Load current settings
            self.load_current_settings()

    def create_gpt_parameters(self):
        """Create GPT model parameters controls"""
        # Max Tokens
        token_frame = tk.Frame(self.gpt_frame, bg=appearance_manager.bg_color)
        token_frame.pack(fill=tk.X, pady=5, padx=5)
        appearance_manager.create_styled_label(token_frame, text="Max Tokens:").pack(
            side=tk.LEFT
        )

        self.gpt_max_tokens = tk.Scale(
            token_frame,
            from_=100,
            to=1000,
            orient=tk.HORIZONTAL,
            resolution=1,
            bg=appearance_manager.bg_color,
            fg="white",
            highlightthickness=0,
        )
        self.gpt_max_tokens.pack(side=tk.RIGHT, expand=True, fill=tk.X, padx=5)

        # Temperature
        temp_frame = tk.Frame(self.gpt_frame, bg=appearance_manager.bg_color)
        temp_frame.pack(fill=tk.X, pady=5, padx=5)
        appearance_manager.create_styled_label(temp_frame, text="Temperature:").pack(
            side=tk.LEFT
        )

        self.gpt_temperature = tk.Scale(
            temp_frame,
            from_=0.1,
            to=0.9,
            orient=tk.HORIZONTAL,
            resolution=0.1,
            bg=appearance_manager.bg_color,
            fg="white",
            highlightthickness=0,
        )
        self.gpt_temperature.pack(side=tk.RIGHT, expand=True, fill=tk.X, padx=5)

        # Top P
        top_p_frame = tk.Frame(self.gpt_frame, bg=appearance_manager.bg_color)
        top_p_frame.pack(fill=tk.X, pady=5, padx=5)
        appearance_manager.create_styled_label(top_p_frame, text="Top P:").pack(
            side=tk.LEFT
        )

        self.gpt_top_p = tk.Scale(
            top_p_frame,
            from_=0.1,
            to=0.9,
            orient=tk.HORIZONTAL,
            resolution=0.1,
            bg=appearance_manager.bg_color,
            fg="white",
            highlightthickness=0,
        )
        self.gpt_top_p.pack(side=tk.RIGHT, expand=True, fill=tk.X, padx=5)

    def create_claude_parameters(self):
        """Create Claude model parameters controls"""
        # Max Tokens
        token_frame = tk.Frame(self.claude_frame, bg=appearance_manager.bg_color)
        token_frame.pack(fill=tk.X, pady=5, padx=5)
        appearance_manager.create_styled_label(token_frame, text="Max Tokens:").pack(
            side=tk.LEFT
        )

        self.claude_max_tokens = tk.Scale(
            token_frame,
            from_=100,
            to=1000,
            orient=tk.HORIZONTAL,
            resolution=1,
            bg=appearance_manager.bg_color,
            fg="white",
            highlightthickness=0,
        )
        self.claude_max_tokens.pack(side=tk.RIGHT, expand=True, fill=tk.X, padx=5)

        # Temperature
        temp_frame = tk.Frame(self.claude_frame, bg=appearance_manager.bg_color)
        temp_frame.pack(fill=tk.X, pady=5, padx=5)
        appearance_manager.create_styled_label(temp_frame, text="Temperature:").pack(
            side=tk.LEFT
        )

        self.claude_temperature = tk.Scale(
            temp_frame,
            from_=0.1,
            to=0.9,
            orient=tk.HORIZONTAL,
            resolution=0.1,
            bg=appearance_manager.bg_color,
            fg="white",
            highlightthickness=0,
        )
        self.claude_temperature.pack(side=tk.RIGHT, expand=True, fill=tk.X, padx=5)

    def load_current_settings(self):
        """Load current settings from settings object"""
        current_params = self.settings.get_api_parameters()

        # Set current model
        model = current_params.get("model", "gpt-4o")
        displayed_model = current_params.get("displayed_model", model)
        self.model_var.set(displayed_model)

        # Load GPT parameters
        self.gpt_max_tokens.set(current_params.get("max_tokens", 500))
        self.gpt_temperature.set(current_params.get("temperature", 0.7))
        self.gpt_top_p.set(current_params.get("top_p", 0.9))

        # Load Claude parameters
        self.claude_max_tokens.set(current_params.get("max_tokens", 500))
        self.claude_temperature.set(current_params.get("temperature", 0.7))

        # Update UI state based on selected model
        self.on_model_change(None)

    def on_model_change(self, event):
        """Handle model selection change"""
        selected_model = self.model_var.get()

        # Enable/disable parameter frames based on model
        if selected_model == "claude-3.5-haiku":
            self.enable_frame(self.claude_frame)
            self.disable_frame(self.gpt_frame)
        else:
            self.enable_frame(self.gpt_frame)
            self.disable_frame(self.claude_frame)

    def enable_frame(self, frame):
        """Enable all controls in a frame"""
        for widget in frame.winfo_children():
            if isinstance(widget, tk.Frame):
                for subwidget in widget.winfo_children():
                    subwidget.configure(state="normal")
            else:
                widget.configure(state="normal")
        frame.configure(fg="white")

    def disable_frame(self, frame):
        """Disable all controls in a frame"""
        for widget in frame.winfo_children():
            if isinstance(widget, tk.Frame):
                for subwidget in widget.winfo_children():
                    subwidget.configure(state="disabled")
            else:
                widget.configure(state="disabled")
        frame.configure(fg="gray")

    def apply_settings(self):
        try:
            selected_model = self.model_var.get()

            # สร้าง parameters ตามประเภท model
            if selected_model == "claude-3.5-haiku":
                api_parameters = {
                    "model": "claude-3-5-haiku-20241022",
                    "max_tokens": int(self.claude_max_tokens.get()),
                    "temperature": float(self.claude_temperature.get()),
                }
            else:
                api_parameters = {
                    "model": selected_model,
                    "max_tokens": int(self.gpt_max_tokens.get()),
                    "temperature": float(self.gpt_temperature.get()),
                    "top_p": float(self.gpt_top_p.get()),
                }

            # ตรวจสอบก่อนบันทึก
            self.settings.validate_model_parameters(api_parameters)

            # เพิ่มบรรทัดนี้เพื่อบันทึกค่าโดยตรง
            success, error = self.settings.set_api_parameters(**api_parameters)
            if not success:
                raise ValueError(error)

            new_settings = {"api_parameters": api_parameters}

            if callable(self.apply_settings_callback):
                self.apply_settings_callback(new_settings)

            # บังคับให้บันทึกลงไฟล์
            self.settings.save_settings()

            self.apply_button.config(text="Applied!")
            self.model_window.after(
                2000, lambda: self.apply_button.config(text="Apply")
            )
            return True

        except Exception as e:
            messagebox.showerror("Error", f"Failed to apply settings: {str(e)}")
            return False

    def open(self):
        """Show the model settings window"""
        if not self.window_created:
            self.create_model_window()

        x = self.parent.winfo_x() + self.parent.winfo_width() + 10
        y = self.parent.winfo_y()
        self.model_window.geometry(f"+{x}+{y}")
        self.model_window.deiconify()
        self.model_window.lift()
        self.model_window.attributes("-topmost", True)

    def close(self):
        """Hide the model settings window"""
        if self.model_window and self.window_created:
            self.model_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):
        if hasattr(self, "x") and hasattr(self, "y"):
            deltax = event.x - self.x
            deltay = event.y - self.y
            x = self.model_window.winfo_x() + deltax
            y = self.model_window.winfo_y() + deltay
            self.model_window.geometry(f"+{x}+{y}")