# create_icon_file.py (Refactored for ProjectUtility integration)

import tkinter as tk
from tkinter import filedialog, messagebox, ttk  # Added ttk
from PIL import Image, ImageTk
import os
import sys
import argparse  # Needed even if tool_utils is used, for initial check
from typing import List, Tuple, Dict, Any, Optional
import logging

# --- Attempt to import tool_utils ---
# Assume tool_utils directory is sibling to this script's directory for simplicity
script_dir = os.path.dirname(os.path.abspath(__file__))
tool_utils_path = os.path.join(
    os.path.dirname(script_dir), "ToolUtils"
)  # Adjust if structure differs

# Add tool_utils path to sys.path IF NOT ALREADY THERE
if tool_utils_path not in sys.path:
    sys.path.insert(0, tool_utils_path)

try:
    from tool_utils.communicator import (
        parse_arguments,
        load_tool_config,
        send_progress,
        send_status,
        send_log,
        send_result,
        print_error,
        exit_success,
    )

    TOOL_UTILS_AVAILABLE = True
except ImportError as e:
    # Provide a basic print_error if tool_utils is missing for managed mode
    def print_error(message: str, exit_code: Optional[int] = 1) -> None:
        print(f"ERROR: {message}", file=sys.stderr, flush=True)
        if exit_code is not None:
            sys.exit(exit_code)

    print_error(
        f"Failed to import tool_utils: {e}. Managed mode requires tool_utils.",
        exit_code=4,
    )
    TOOL_UTILS_AVAILABLE = False  # Fallback, though script will likely exit above


# --- Core Conversion Logic ---


def remove_white_background(img: Image.Image) -> Image.Image:
    """Makes white or near-white pixels transparent."""
    if img.mode != "RGBA":
        img = img.convert("RGBA")
    datas = img.getdata()
    newData = []
    # Threshold for 'white' (adjust if needed)
    white_threshold = 240
    for item in datas:
        # item is (R, G, B, A)
        if (
            item[0] > white_threshold
            and item[1] > white_threshold
            and item[2] > white_threshold
        ):
            # Pixel is white/near-white: make it transparent (keep original alpha if needed?)
            # For simplicity, setting alpha to 0 for white.
            newData.append((item[0], item[1], item[2], 0))  # Make transparent
        else:
            newData.append(item)  # Keep original pixel
    img.putdata(newData)
    return img


def parse_sizes(sizes_str: str) -> List[Tuple[int, int]]:
    """Parses comma-separated size string into list of tuples."""
    parsed_sizes = []
    if not sizes_str or not isinstance(sizes_str, str):
        return []  # Return empty if no string provided
    parts = sizes_str.split(",")
    for part in parts:
        part = part.strip()
        if part.isdigit():
            size_val = int(part)
            if size_val > 0:
                parsed_sizes.append((size_val, size_val))
            else:
                raise ValueError(f"Invalid size '{part}': must be a positive integer.")
        else:
            raise ValueError(f"Invalid size format '{part}': expected integer.")
    if not parsed_sizes:
        raise ValueError("No valid sizes found in size string.")
    return parsed_sizes


def perform_conversion(
    input_path: str,
    output_path: str,
    remove_bg: bool,
    sizes_list: List[Tuple[int, int]],
) -> Dict[str, Any]:
    """
    Performs the core PNG to ICO conversion.

    Args:
        input_path: Path to the source PNG file.
        output_path: Path where the ICO file will be saved.
        remove_bg: Whether to attempt removing white background.
        sizes_list: List of (width, height) tuples for the ICO sizes.

    Returns:
        A dictionary containing result information (e.g., output file path).

    Raises:
        FileNotFoundError: If input file doesn't exist.
        Exception: For other PIL errors or issues during conversion.
    """
    if not os.path.isfile(input_path):
        raise FileNotFoundError(f"Input PNG file not found: {input_path}")
    if not sizes_list:
        raise ValueError("No valid sizes provided for ICO generation.")

    img = Image.open(input_path)

    # Ensure RGBA for transparency handling
    if img.mode != "RGBA":
        img = img.convert("RGBA")

    # Remove background if requested
    if remove_bg:
        img = remove_white_background(img)  # Use the refactored function

    # Save the ICO file with specified sizes
    img.save(output_path, format="ICO", sizes=sizes_list)

    return {"output_file": output_path, "sizes_generated": sizes_list}


# --- Standalone Tkinter GUI Application ---


class PNGtoICOApp:
    def __init__(self, root):
        self.root = root
        self.root.title("PNG to ICO Converter (Standalone)")
        self.root.geometry("600x700")
        # self.root.resizable(False, False) # Allow resizing

        self.png_path: Optional[str] = None
        self.preview_img: Optional[ImageTk.PhotoImage] = None
        self.ico_previews: List[ImageTk.PhotoImage] = (
            []
        )  # Keep track to avoid garbage collection

        # --- GUI Widgets ---
        top_frame = ttk.Frame(root, padding="10")
        top_frame.pack(fill=tk.X)

        ttk.Label(
            top_frame, text="Convert PNG to ICO", font=("Segoe UI", 12, "bold")
        ).pack()

        select_frame = ttk.Frame(top_frame)
        select_frame.pack(fill=tk.X, pady=5)
        self.select_button = ttk.Button(
            select_frame, text="Select PNG Image", command=self.select_image
        )
        self.select_button.pack(side=tk.LEFT, padx=(0, 10))
        self.preview_label = ttk.Label(
            select_frame, text="No image selected.", style="Italic.TLabel"
        )  # Using style
        self.preview_label.pack(side=tk.LEFT)

        self.image_label = ttk.Label(root)  # Label to show the 128x128 preview
        self.image_label.pack(pady=10)

        options_frame = ttk.Frame(root, padding="0 0 0 10")
        options_frame.pack(fill=tk.X)

        self.remove_bg_var = tk.BooleanVar(value=True)
        self.remove_bg_checkbox = ttk.Checkbutton(
            options_frame,
            text="Remove white/near-white background",
            variable=self.remove_bg_var,
        )
        self.remove_bg_checkbox.pack(pady=5, anchor="w")

        # Add Sizes input (optional for GUI, uses default if empty)
        size_frame = ttk.Frame(options_frame)
        size_frame.pack(fill=tk.X, pady=5)
        ttk.Label(size_frame, text="Sizes (csv):").pack(side=tk.LEFT, padx=(0, 5))
        self.sizes_var = tk.StringVar(value="16,32,48,64,128,256")  # Default sizes
        self.sizes_entry = ttk.Entry(size_frame, textvariable=self.sizes_var, width=40)
        self.sizes_entry.pack(side=tk.LEFT, fill=tk.X, expand=True)

        self.convert_button = ttk.Button(
            root,
            text="Convert and Save ICO",
            command=self.run_conversion_gui,
            state=tk.DISABLED,
        )
        self.convert_button.pack(pady=10)

        # --- Preview Area ---
        preview_container = ttk.LabelFrame(
            root, text="Generated Size Previews", padding="10"
        )
        preview_container.pack(fill="both", expand=True, padx=10, pady=(0, 10))

        self.canvas = tk.Canvas(
            preview_container, borderwidth=0, background="#ffffff"
        )  # Set background
        self.scroll_y = ttk.Scrollbar(
            preview_container, orient="vertical", command=self.canvas.yview
        )
        self.scroll_frame = ttk.Frame(
            self.canvas, style="Preview.TFrame"
        )  # Use a style for the frame

        self.scroll_frame.bind(
            "<Configure>",
            lambda e: self.canvas.configure(scrollregion=self.canvas.bbox("all")),
        )

        self.canvas_window = self.canvas.create_window(
            (0, 0), window=self.scroll_frame, anchor="nw"
        )
        self.canvas.configure(yscrollcommand=self.scroll_y.set)
        # Adjust canvas window width when canvas resizes
        self.canvas.bind(
            "<Configure>",
            lambda e: self.canvas.itemconfig(self.canvas_window, width=e.width),
        )

        self.canvas.pack(side="left", fill="both", expand=True)
        self.scroll_y.pack(side="right", fill="y")

        # --- Styles ---
        style = ttk.Style()
        style.configure("Italic.TLabel", font=("Segoe UI", 9, "italic"))
        style.configure(
            "Preview.TFrame", background="#ffffff"
        )  # Match canvas background

    def select_image(self):
        """Handles PNG image selection in GUI mode."""
        # Use previously selected dir or script dir
        initial_dir = os.path.dirname(self.png_path) if self.png_path else script_dir

        path = filedialog.askopenfilename(
            title="Select PNG Image",
            initialdir=initial_dir,
            filetypes=[("PNG files", "*.png")],
        )
        if not path:
            return

        self.png_path = path
        self.preview_label.config(
            text=os.path.basename(path), style="TLabel"
        )  # Reset style

        try:
            img = Image.open(path)
            # Create a 128x128 thumbnail for the main preview
            img_thumb = img.copy()
            img_thumb.thumbnail((128, 128), Image.LANCZOS)
            self.preview_img = ImageTk.PhotoImage(img_thumb)
            self.image_label.config(image=self.preview_img)
            self.convert_button.config(state=tk.NORMAL)
            self.clear_previews()  # Clear old previews
        except Exception as e:
            messagebox.showerror("Error", f"Failed to load or preview image:\n{e}")
            self.png_path = None
            self.preview_label.config(
                text="Error loading image.", style="Error.TLabel"
            )  # Add Error style if needed
            self.image_label.config(image="")
            self.convert_button.config(state=tk.DISABLED)

    def run_conversion_gui(self):
        """Initiates the conversion process from the GUI."""
        if not self.png_path:
            messagebox.showwarning("Input Missing", "Please select a PNG image first.")
            return

        default_name = os.path.splitext(os.path.basename(self.png_path))[0] + ".ico"
        output_path = filedialog.asksaveasfilename(
            title="Save ICO As",
            defaultextension=".ico",
            initialfile=default_name,
            initialdir=os.path.dirname(self.png_path),  # Start in image dir
            filetypes=[("ICO files", "*.ico")],
        )

        if not output_path:
            return  # User cancelled save dialog

        # Get options from GUI
        remove_bg_flag = self.remove_bg_var.get()
        sizes_str = self.sizes_var.get()

        try:
            sizes_list = parse_sizes(sizes_str)  # Use the parser function
            if not sizes_list:  # Should be caught by parse_sizes, but double check
                raise ValueError("No valid sizes specified.")

            # --- Call the core logic function ---
            result_info = perform_conversion(
                input_path=self.png_path,
                output_path=output_path,
                remove_bg=remove_bg_flag,
                sizes_list=sizes_list,
            )
            base_img = Image.open(self.png_path)  # Re-open base image for previews
            # Applica la stessa logica di rimozione sfondo per coerenza nelle anteprime
            if remove_bg_flag:
                base_img = remove_white_background(base_img)

            # 2. Mostra le anteprime PRIMA del messaggio di successo
            self.show_generated_previews(base_img, result_info["sizes_generated"])

            # 3. (Opzionale ma consigliato) Forza l'aggiornamento dell'interfaccia
            #    per assicurarsi che le anteprime siano visibili prima del popup bloccante
            self.root.update_idletasks()

            # 4. Mostra il messaggio di successo DOPO aver mostrato le anteprime
            messagebox.showinfo(
                "Success", f"ICO file saved successfully:\n{result_info['output_file']}"
            )

        except ValueError as ve:  # Catch specific errors like invalid sizes
            messagebox.showerror("Configuration Error", f"Error in configuration: {ve}")
        except FileNotFoundError as fnf:
            messagebox.showerror("File Error", f"{fnf}")
        except Exception as e:
            messagebox.showerror(
                "Conversion Error", f"An error occurred during conversion:\n{e}"
            )

    def show_generated_previews(
        self, base_img: Image.Image, sizes: List[Tuple[int, int]]
    ):
        """Displays previews of generated icon sizes in the scrollable frame."""
        self.clear_previews()
        self.ico_previews = []  # Clear old PhotoImage refs

        columns = 4  # Adjust number of columns for previews
        max_preview_dim = 64  # Max dimension for preview image itself

        for i, size in enumerate(sizes):
            # Create a scaled preview, but don't make it huge
            preview_size = (
                min(size[0], max_preview_dim),
                min(size[1], max_preview_dim),
            )
            preview_pil = base_img.copy()
            preview_pil.thumbnail(
                preview_size, Image.LANCZOS
            )  # Use thumbnail for better quality scaling down
            preview_img = ImageTk.PhotoImage(preview_pil)
            self.ico_previews.append(preview_img)  # Store reference!

            # Frame for each preview item
            frame = ttk.Frame(self.scroll_frame, padding=5, style="Preview.TFrame")
            frame.grid(
                row=(i // columns), column=i % columns, padx=5, pady=5, sticky="n"
            )

            # Use tooltips (simple version via label text, better libraries exist)
            # Or just rely on the size text
            img_label = ttk.Label(
                frame, image=preview_img, style="Preview.TLabel"
            )  # Use styled label
            img_label.pack()
            size_label = ttk.Label(
                frame, text=f"{size[0]}x{size[1]}", style="Preview.TLabel"
            )
            size_label.pack()

        # Update canvas scroll region after adding all widgets
        self.scroll_frame.update_idletasks()
        self.canvas.configure(scrollregion=self.canvas.bbox("all"))

    def clear_previews(self):
        """Clears the preview area."""
        for widget in self.scroll_frame.winfo_children():
            widget.destroy()
        self.ico_previews.clear()


# --- Main Execution Logic ---


def run_managed_mode():
    """Runs the tool in non-interactive mode, controlled by ProjectUtility."""
    if not TOOL_UTILS_AVAILABLE:
        # Error already printed during import attempt
        sys.exit(4)  # Exit if utils couldn't be loaded

    send_status("Icon Generator tool started (managed mode).")

    # 1. Load configuration to get parameter definitions
    config = load_tool_config()  # Assumes tool_config.json is in the same dir
    if config is None:
        # Error message already printed by load_tool_config to stderr
        sys.exit(3)  # Specific exit code for config load failure

    tool_params_def = config.get("parameters", [])

    # 2. Parse arguments using tool_utils based on the definition
    try:
        args = parse_arguments(tool_params_def)
    except Exception as e:
        # parse_arguments might exit, but catch errors just in case
        print_error(f"Critical error parsing arguments: {e}", exit_code=2)
        sys.exit(2)  # Ensure exit

    # Extract arguments (use defaults defined in config if not provided/required)
    input_file = args.input_png
    output_file = args.output_ico
    remove_bg_flag = args.remove_bg  # Will be True if --remove-bg passed, else False
    sizes_str = args.sizes  # Default value from config used by argparse if not passed

    # 3. Perform Core Logic
    try:
        send_status(f"Input PNG: {input_file}")
        send_status(f"Output ICO: {output_file}")
        send_status(f"Remove Background: {remove_bg_flag}")
        send_status(f"Sizes String: '{sizes_str}'")

        # Parse sizes string here
        sizes_list = parse_sizes(sizes_str)
        send_status(f"Parsed sizes: {sizes_list}")

        send_progress(0.1, "Starting conversion...")  # Initial progress

        # Call the core conversion function
        result_info = perform_conversion(
            input_path=input_file,
            output_path=output_file,
            remove_bg=remove_bg_flag,
            sizes_list=sizes_list,
        )

        send_progress(1.0, "Conversion finished.")  # Final progress

        # 4. Send results
        send_result(result_info)

        # 5. Exit successfully
        exit_success(f"ICO file generated successfully at {result_info['output_file']}")

    except FileNotFoundError as fnf:
        print_error(
            f"File error: {fnf}", exit_code=3
        )  # Specific code for file not found
    except ValueError as ve:
        print_error(
            f"Configuration or Value Error: {ve}", exit_code=2
        )  # Specific code for bad input/config
    except ImportError as imp_err:
        # Catch potential Pillow import error if not installed
        print_error(
            f"Import Error: {imp_err}. Is Pillow installed (`pip install Pillow`)?",
            exit_code=6,
        )
    except Exception as e:
        # Catch unexpected errors during conversion
        # Log the full traceback using print_error's logger is helpful
        import traceback

        tb_str = traceback.format_exc()
        print_error(
            f"An unexpected error occurred during conversion: {e}\nTraceback:\n{tb_str}",
            exit_code=1,
        )


def run_standalone_mode():
    """Runs the tool as a standalone Tkinter GUI application."""
    try:
        root = tk.Tk()
        # Apply themed widgets if available
        try:
            style = ttk.Style(root)
            # Examples: 'clam', 'alt', 'default', 'classic' (depends on OS)
            available_themes = style.theme_names()
            # Prefer modern themes if available
            for theme in ["clam", "alt", "default"]:
                if theme in available_themes:
                    style.theme_use(theme)
                    break
        except tk.TclError:
            print(
                "INFO: ttk themes not fully available.", file=sys.stderr
            )  # Inform user

        app = PNGtoICOApp(root)
        root.mainloop()
    except ImportError as e:
        # Catch Pillow import error specifically for GUI mode too
        message = f"ERROR: Required library Pillow (PIL) is not installed.\nPlease install it using:\n pip install Pillow\n\nDetails: {e}"
        # Try showing a simple Tk message box if possible, otherwise print
        try:
            root = tk.Tk()
            root.withdraw()  # Hide main window
            messagebox.showerror("Missing Dependency", message)
            root.destroy()
        except tk.TclError:
            print(message, file=sys.stderr)
        sys.exit(6)  # Exit code for dependency error
    except Exception as e:
        # Catch other potential GUI startup errors
        message = f"ERROR: Failed to start the GUI application.\nDetails: {e}"
        try:
            root = tk.Tk()
            root.withdraw()
            messagebox.showerror("Startup Error", message)
            root.destroy()
        except tk.TclError:
            print(message, file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    # --- Determine run mode ---
    # Simple check: If arguments exist beyond the script name itself,
    # assume it's an attempt to run in managed mode via command line.
    # Standalone GUI execution typically won't have extra arguments.
    # This avoids complex (and potentially faulty) pre-parsing.
    is_managed_run_attempt = len(sys.argv) > 1

    if is_managed_run_attempt:
        # Configure minimal logging just in case tool_utils failed import,
        # otherwise tool_utils or the tool itself should handle logging.
        try:
            if not TOOL_UTILS_AVAILABLE:
                logging.basicConfig(
                    level=logging.WARNING,
                    format="%(name)s - %(levelname)s - %(message)s",
                    stream=sys.stderr,
                )
            logger = logging.getLogger(__name__)  # Get logger for this script
            logger.info(
                "Command-line arguments detected. Attempting to run in managed mode."
            )
        except Exception:
            pass  # Ignore logging setup errors here

        # Execute the managed mode logic
        run_managed_mode()

    else:
        # Configure minimal logging for GUI mode if needed
        try:
            logging.basicConfig(
                level=logging.INFO,
                format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
            )
            logger = logging.getLogger(__name__)
            logger.info(
                "No command-line arguments detected. Attempting to run in standalone GUI mode."
            )
        except Exception:
            pass

        # Execute the standalone GUI logic
        run_standalone_mode()

    if is_managed_run_attempt:
        run_managed_mode()
    else:
        run_standalone_mode()