# radar_data_reader/gui/profile_editor_window.py

"""
GUI Window for creating, editing, and deleting export profiles.
"""

import tkinter as tk
from tkinter import ttk, simpledialog, messagebox
import ctypes
import copy
from typing import List, Type, Dict, Any, Union, Optional

from ..core import data_structures as ds
from ..core.data_enums import ENUM_REGISTRY
from ..core.export_profiles import ExportProfile, ExportField
from ..utils import logger

log = logger.get_logger(__name__)


class ProfileEditorWindow(tk.Toplevel):
    """A Toplevel window for managing export profiles."""

    def __init__(self, master, controller, profiles: List[ExportProfile]):
        super().__init__(master)
        self.master = master
        self.controller = controller

        self.profiles = copy.deepcopy(profiles)
        self._original_profiles_dict = {p.name: p.to_dict() for p in self.profiles}

        self._init_window()
        self._init_vars()
        self._create_widgets()

        self._populate_available_fields_tree()
        self._load_profiles_to_combobox()
        self.protocol("WM_DELETE_WINDOW", self._on_close)

    def _init_window(self):
        """Initializes window properties."""
        self.title("Export Profile Editor")
        self.geometry("1000x600")
        self.transient(self.master)
        self.grab_set()

    def _init_vars(self):
        """Initializes Tkinter variables."""
        self.selected_profile_name = tk.StringVar()

    def _create_widgets(self):
        """Creates the main layout and widgets for the editor."""
        main_pane = ttk.PanedWindow(self, orient=tk.HORIZONTAL)
        main_pane.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

        # --- Left Frame: Profile Management ---
        profile_mgmt_frame = ttk.LabelFrame(main_pane, text="Profiles")
        main_pane.add(profile_mgmt_frame, weight=1)
        profile_mgmt_frame.columnconfigure(0, weight=1)

        cb_frame = ttk.Frame(profile_mgmt_frame)
        cb_frame.grid(row=0, column=0, sticky="ew", padx=5, pady=5)
        cb_frame.columnconfigure(0, weight=1)
        self.profile_combobox = ttk.Combobox(
            cb_frame, textvariable=self.selected_profile_name, state="readonly"
        )
        self.profile_combobox.grid(row=0, column=0, sticky="ew")
        self.profile_combobox.bind("<<ComboboxSelected>>", self._on_profile_selected)

        btn_frame = ttk.Frame(profile_mgmt_frame)
        btn_frame.grid(row=1, column=0, sticky="ew", padx=5)
        btn_frame.columnconfigure((0, 1), weight=1)
        ttk.Button(btn_frame, text="New", command=self._on_new_profile).grid(
            row=0, column=0, sticky="ew", padx=2
        )
        ttk.Button(btn_frame, text="Delete", command=self._on_delete_profile).grid(
            row=0, column=1, sticky="ew", padx=2
        )

        # --- Middle Frame: Available Fields ---
        fields_frame = ttk.LabelFrame(main_pane, text="Available Fields")
        main_pane.add(fields_frame, weight=2)
        fields_frame.rowconfigure(0, weight=1)
        fields_frame.columnconfigure(0, weight=1)
        self.fields_tree = ttk.Treeview(fields_frame, selectmode="browse")
        self.fields_tree.grid(row=0, column=0, sticky="nsew", padx=5, pady=5)
        ysb = ttk.Scrollbar(
            fields_frame, orient="vertical", command=self.fields_tree.yview
        )
        self.fields_tree.configure(yscrollcommand=ysb.set)
        ysb.grid(row=0, column=1, sticky="ns")

        # --- Right Frame: Selected Fields and Actions ---
        selected_frame_container = ttk.Frame(main_pane)
        main_pane.add(selected_frame_container, weight=3)
        selected_frame_container.rowconfigure(0, weight=1)
        selected_frame_container.columnconfigure(1, weight=1)

        action_btn_frame = ttk.Frame(selected_frame_container)
        action_btn_frame.grid(row=0, column=0, sticky="ns", padx=5, pady=5)
        ttk.Button(action_btn_frame, text=">>", command=self._add_field).grid(pady=5)
        ttk.Button(action_btn_frame, text="<<", command=self._remove_field).grid(pady=5)
        ttk.Button(
            action_btn_frame, text="Up", command=lambda: self._move_field(-1)
        ).grid(pady=20)
        ttk.Button(
            action_btn_frame, text="Down", command=lambda: self._move_field(1)
        ).grid(pady=5)

        selected_fields_frame = ttk.LabelFrame(
            selected_frame_container, text="Selected Fields for Profile"
        )
        selected_fields_frame.grid(row=0, column=1, sticky="nsew")
        selected_fields_frame.rowconfigure(0, weight=1)
        selected_fields_frame.columnconfigure(0, weight=1)

        self.selected_tree = ttk.Treeview(
            selected_fields_frame,
            columns=("display_name", "translate"),
            show="headings",
            selectmode="browse",
        )
        self.selected_tree.heading("display_name", text="Field Name")
        self.selected_tree.heading("translate", text="Translate")
        self.selected_tree.column("display_name", width=200, stretch=True)
        self.selected_tree.column(
            "translate", width=100, anchor="center", stretch=False
        )
        self.selected_tree.grid(row=0, column=0, sticky="nsew")
        self.selected_tree.bind("<Button-1>", self._on_selected_tree_click)

        # --- Bottom Frame: Save/Cancel ---
        bottom_frame = ttk.Frame(self)
        bottom_frame.pack(fill=tk.X, padx=10, pady=(0, 10))
        ttk.Button(
            bottom_frame, text="Save & Close", command=self._on_save_and_close
        ).pack(side=tk.RIGHT)
        ttk.Button(bottom_frame, text="Cancel", command=self._on_close).pack(
            side=tk.RIGHT, padx=5
        )

    def _on_selected_tree_click(self, event):
        region = self.selected_tree.identify_region(event.x, event.y)
        if region != "cell":
            return

        column_id = self.selected_tree.identify_column(event.x)
        if column_id != "#2":
            return

        item_id = self.selected_tree.identify_row(event.y)
        if not item_id:
            return

        profile = self._get_current_profile()
        if not profile:
            return

        field_index = int(item_id)
        field = profile.fields[field_index]

        if field.data_path in ENUM_REGISTRY:
            field.translate_with_enum = not field.translate_with_enum
            self._load_profile_into_ui()

    def _populate_available_fields_tree(self):
        self.fields_tree.delete(*self.fields_tree.get_children())

        # --- Batch Properties (standalone fields) ---
        batch_root = self.fields_tree.insert(
            "", "end", iid="batch_properties", text="Batch Properties"
        )
        self.fields_tree.insert(
            batch_root,
            "end",
            iid="batch_id",
            text="batch_id",
            values=("batch_id", "batch_id"),
        )

        # --- DSPHDRIN Data ---
        header_root = self.fields_tree.insert(
            "", "end", iid="header_data", text="Header Data (from DSPHDRIN)"
        )
        self._recursive_populate_tree_ctypes(
            ds.GeHeader, header_root, "main_header.ge_header"
        )

        # --- CDPSTS Data ---
        cdpsts_root = self.fields_tree.insert(
            "", "end", iid="cdpsts_data", text="CDP/STS Block Data"
        )
        # Explore the CdpDataLayout, which is nested inside cdp_sts_results.payload
        self._recursive_populate_tree_ctypes(
            ds.CdpDataLayout, cdpsts_root, "cdp_sts_results.payload.data"
        )

    def _recursive_populate_tree_ctypes(
        self, class_obj: Type[ctypes.Structure], parent_id: str, base_path: str
    ):
        """Recursively populates a Treeview with fields from a ctypes.Structure."""
        if not hasattr(class_obj, "_fields_"):
            return

        for field_name, field_type in class_obj._fields_:
            current_path = f"{base_path}.{field_name}"
            node_id = f"{parent_id}_{field_name}"

            # Check if the field type is another ctypes.Structure
            if hasattr(field_type, "_fields_"):
                child_node = self.fields_tree.insert(
                    parent_id, "end", iid=node_id, text=field_name
                )
                self._recursive_populate_tree_ctypes(
                    field_type, child_node, current_path
                )

            # Check if it's a ctypes array
            elif hasattr(field_type, "_length_"):
                # For arrays, we don't expand further in the tree, just show it's an array
                self.fields_tree.insert(
                    parent_id,
                    "end",
                    iid=node_id,
                    text=f"{field_name} [Array]",
                    values=(field_name, current_path),
                )

            # It's a primitive ctypes field (c_int, c_float, etc.)
            else:
                display_text = f"{field_name}"
                if current_path in ENUM_REGISTRY:
                    display_text += " (Enum)"
                self.fields_tree.insert(
                    parent_id,
                    "end",
                    iid=node_id,
                    text=display_text,
                    values=(field_name, current_path),
                )

    def _load_profiles_to_combobox(self):
        profile_names = [p.name for p in self.profiles]
        self.profile_combobox["values"] = profile_names
        if profile_names:
            self.selected_profile_name.set(profile_names[0])
        self._load_profile_into_ui()

    def _get_current_profile(self) -> Optional[ExportProfile]:
        name = self.selected_profile_name.get()
        return next((p for p in self.profiles if p.name == name), None)

    def _on_profile_selected(self, event=None):
        self._load_profile_into_ui()

    def _load_profile_into_ui(self):
        for i in self.selected_tree.get_children():
            self.selected_tree.delete(i)

        profile = self._get_current_profile()
        if not profile:
            return

        for index, field in enumerate(profile.fields):
            is_translatable = field.data_path in ENUM_REGISTRY
            checkbox_char = "☐"
            if is_translatable:
                checkbox_char = "☑" if field.translate_with_enum else "☐"

            self.selected_tree.insert(
                "", "end", iid=str(index), values=(field.column_name, checkbox_char)
            )

    def _add_field(self):
        selected_item_id = self.fields_tree.focus()
        if not selected_item_id:
            return

        item_values = self.fields_tree.item(selected_item_id, "values")
        if not item_values or len(item_values) < 2:
            messagebox.showinfo(
                "Cannot Add Field", "Please select a specific data field.", parent=self
            )
            return

        column_name, data_path = item_values
        profile = self._get_current_profile()
        if not profile:
            return

        if any(f.data_path == data_path for f in profile.fields):
            messagebox.showinfo(
                "Duplicate Field", "This field is already in the profile.", parent=self
            )
            return

        profile.fields.append(ExportField(column_name=column_name, data_path=data_path))
        self._load_profile_into_ui()

    def _remove_field(self):
        selection = self.selected_tree.selection()
        if not selection:
            return

        index_to_remove = int(selection[0])
        profile = self._get_current_profile()
        if not profile:
            return

        del profile.fields[index_to_remove]
        self._load_profile_into_ui()

    def _move_field(self, direction: int):
        selection = self.selected_tree.selection()
        if not selection:
            return

        index = int(selection[0])
        new_index = index + direction

        profile = self._get_current_profile()
        if not profile or not (0 <= new_index < len(profile.fields)):
            return

        fields = profile.fields
        fields.insert(new_index, fields.pop(index))
        self._load_profile_into_ui()
        self.selected_tree.selection_set(str(new_index))

    def _on_new_profile(self):
        name = simpledialog.askstring(
            "New Profile", "Enter a name for the new profile:", parent=self
        )
        if not name or not name.strip():
            return

        if any(p.name == name for p in self.profiles):
            messagebox.showerror(
                "Error",
                f"A profile with the name '{name}' already exists.",
                parent=self,
            )
            return

        new_profile = ExportProfile(name=name.strip())
        self.profiles.append(new_profile)
        self._load_profiles_to_combobox()
        self.selected_profile_name.set(name)
        self._load_profile_into_ui()

    def _on_delete_profile(self):
        profile = self._get_current_profile()
        if not profile:
            return

        if messagebox.askyesno(
            "Confirm Delete",
            f"Are you sure you want to delete the profile '{profile.name}'?",
            parent=self,
        ):
            self.profiles.remove(profile)
            self._load_profiles_to_combobox()

    def _check_unsaved_changes(self) -> bool:
        current_profiles_dict = {p.name: p.to_dict() for p in self.profiles}
        return current_profiles_dict != self._original_profiles_dict

    def _on_save_and_close(self):
        log.info("Saving export profiles and closing editor.")
        self.controller.save_export_profiles(self.profiles)
        self.destroy()

    def _on_close(self):
        if self._check_unsaved_changes():
            response = messagebox.askyesnocancel(
                "Unsaved Changes",
                "You have unsaved changes. Would you like to save them?",
                parent=self,
            )
            if response is True:
                self._on_save_and_close()
            elif response is False:
                self.destroy()
        else:
            self.destroy()