# File: cpp_python_debug/gui/profile_manager_window.py
# (Assicurati che gli import siano corretti, specialmente per ActionEditorWindow)
import tkinter as tk
from tkinter import ttk, messagebox, filedialog  # Removed scrolledtext for actions JSON
import logging
import json
import os
from typing import TYPE_CHECKING, List, Dict, Any, Optional

# NEW: Import ActionEditorWindow
from .action_editor_window import ActionEditorWindow

if TYPE_CHECKING:
    from ..core.config_manager import AppSettings
    from .main_window import GDBGui

logger = logging.getLogger(__name__)

# Default structure for a new action (remains useful)
DEFAULT_ACTION = {
    "breakpoint_location": "main",
    "variables_to_dump": ["my_variable"],
    "output_format": "json",
    "output_directory": "./debug_dumps",
    "filename_pattern": "{profile_name}_{breakpoint}_{variable}_{timestamp}.{format}",
    "continue_after_dump": True,
}

# Default structure for a new profile (actions will be an empty list initially or one default)
DEFAULT_PROFILE = {
    "profile_name": "New Profile",
    "target_executable": "",
    "program_parameters": "",
    "actions": [],  # Start with an empty list, actions are added via UI
}


class ProfileManagerWindow(tk.Toplevel):
    # ... (init, _load_profiles_from_settings, etc. rimangono simili) ...
    def __init__(self, parent: "GDBGui", app_settings: "AppSettings"):
        super().__init__(parent)
        self.parent_window = parent
        self.app_settings = app_settings

        self.title("Profile Manager")
        self.geometry("950x700")

        self.transient(parent)
        self.grab_set()

        self._profiles_data: List[Dict[str, Any]] = []
        self._selected_profile_index: Optional[int] = None
        self._selected_action_index_in_profile: Optional[int] = None  # NEW
        self._current_profile_modified_in_form: bool = False
        self._profiles_list_changed_overall: bool = False

        self.profile_name_var = tk.StringVar()
        self.target_exe_var = tk.StringVar()
        self.program_params_var = tk.StringVar()

        self._load_profiles_from_settings()
        self._create_widgets()  # This will now include the new actions list UI
        self._populate_profiles_listbox()

        if self._profiles_data:
            self._select_profile_by_index(0)

        self.protocol("WM_DELETE_WINDOW", self._on_closing_button)

        self.profile_name_var.trace_add("write", self._mark_form_as_modified)
        self.target_exe_var.trace_add("write", self._mark_form_as_modified)
        self.program_params_var.trace_add("write", self._mark_form_as_modified)

    def _mark_form_as_modified(self, *args):
        self._current_profile_modified_in_form = True

    def _load_profiles_from_settings(self) -> None:
        self._profiles_data = []
        loaded_profiles = self.app_settings.get_profiles()
        for profile_dict in loaded_profiles:
            # Ensure 'actions' key exists and is a list, make a deep copy for editing
            copied_profile = profile_dict.copy()  # shallow copy of top-level
            copied_profile["actions"] = [
                action.copy() for action in profile_dict.get("actions", [])
            ]  # deep copy of actions list
            self._profiles_data.append(copied_profile)

        self._profiles_list_changed_overall = False
        logger.debug(
            f"Loaded {len(self._profiles_data)} profiles into ProfileManagerWindow."
        )

    def _create_widgets(self) -> None:
        main_frame = ttk.Frame(self, padding="10")
        main_frame.pack(expand=True, fill=tk.BOTH)

        main_frame.columnconfigure(0, weight=1, minsize=200)
        main_frame.columnconfigure(1, weight=3)
        main_frame.rowconfigure(0, weight=1)
        main_frame.rowconfigure(1, weight=0)

        left_pane = ttk.Frame(main_frame)
        left_pane.grid(row=0, column=0, sticky="nsew", padx=(0, 10))
        left_pane.rowconfigure(0, weight=1)
        left_pane.rowconfigure(1, weight=0)
        left_pane.columnconfigure(0, weight=1)

        profiles_list_frame = ttk.LabelFrame(left_pane, text="Profiles", padding="5")
        profiles_list_frame.grid(row=0, column=0, sticky="nsew", pady=(0, 5))
        profiles_list_frame.rowconfigure(0, weight=1)
        profiles_list_frame.columnconfigure(0, weight=1)

        self.profiles_listbox = tk.Listbox(
            profiles_list_frame, exportselection=False, selectmode=tk.SINGLE
        )
        self.profiles_listbox.grid(row=0, column=0, sticky="nsew")
        self.profiles_listbox.bind("<<ListboxSelect>>", self._on_profile_select)

        listbox_scrollbar_y = ttk.Scrollbar(
            profiles_list_frame, orient=tk.VERTICAL, command=self.profiles_listbox.yview
        )
        listbox_scrollbar_y.grid(row=0, column=1, sticky="ns")
        self.profiles_listbox.configure(yscrollcommand=listbox_scrollbar_y.set)

        profiles_list_controls_frame = ttk.Frame(left_pane)
        profiles_list_controls_frame.grid(row=1, column=0, sticky="ew", pady=5)

        ttk.Button(
            profiles_list_controls_frame, text="New", command=self._new_profile
        ).pack(side=tk.LEFT, padx=2, fill=tk.X, expand=True)
        self.duplicate_button = ttk.Button(
            profiles_list_controls_frame,
            text="Duplicate",
            command=self._duplicate_profile,
            state=tk.DISABLED,
        )
        self.duplicate_button.pack(side=tk.LEFT, padx=2, fill=tk.X, expand=True)
        self.delete_button = ttk.Button(
            profiles_list_controls_frame,
            text="Delete",
            command=self._delete_profile,
            state=tk.DISABLED,
        )
        self.delete_button.pack(side=tk.LEFT, padx=2, fill=tk.X, expand=True)

        right_pane = ttk.Frame(main_frame)
        right_pane.grid(row=0, column=1, sticky="nsew")
        right_pane.rowconfigure(1, weight=1)  # Actions list/controls will go here
        right_pane.columnconfigure(0, weight=1)

        details_form_frame = ttk.LabelFrame(
            right_pane, text="Profile Details", padding="10"
        )
        details_form_frame.grid(row=0, column=0, sticky="new", pady=(0, 5))
        details_form_frame.columnconfigure(1, weight=1)

        ttk.Label(details_form_frame, text="Profile Name:").grid(
            row=0, column=0, sticky=tk.W, padx=5, pady=3
        )
        self.profile_name_entry = ttk.Entry(
            details_form_frame,
            textvariable=self.profile_name_var,
            width=60,
            state=tk.DISABLED,
        )
        self.profile_name_entry.grid(row=0, column=1, sticky="ew", padx=5, pady=3)

        ttk.Label(details_form_frame, text="Target Executable:").grid(
            row=1, column=0, sticky=tk.W, padx=5, pady=3
        )
        self.target_exe_entry = ttk.Entry(
            details_form_frame, textvariable=self.target_exe_var, state=tk.DISABLED
        )
        self.target_exe_entry.grid(row=1, column=1, sticky="ew", padx=5, pady=3)
        self.browse_exe_button = ttk.Button(
            details_form_frame,
            text="Browse...",
            command=self._browse_target_executable,
            state=tk.DISABLED,
        )
        self.browse_exe_button.grid(row=1, column=2, padx=5, pady=3)

        ttk.Label(details_form_frame, text="Program Parameters:").grid(
            row=2, column=0, sticky=tk.W, padx=5, pady=3
        )
        self.program_params_entry = ttk.Entry(
            details_form_frame, textvariable=self.program_params_var, state=tk.DISABLED
        )
        self.program_params_entry.grid(
            row=2, column=1, columnspan=2, sticky="ew", padx=5, pady=3
        )

        # --- NEW: Actions Management UI ---
        actions_ui_frame = ttk.LabelFrame(
            right_pane, text="Debug Actions", padding="10"
        )
        actions_ui_frame.grid(row=1, column=0, sticky="nsew", pady=5)
        actions_ui_frame.rowconfigure(0, weight=1)  # Listbox for actions
        actions_ui_frame.columnconfigure(0, weight=1)  # Listbox
        actions_ui_frame.columnconfigure(1, weight=0)  # Buttons for actions

        self.actions_listbox = tk.Listbox(
            actions_ui_frame, exportselection=False, selectmode=tk.SINGLE, height=8
        )
        self.actions_listbox.grid(row=0, column=0, sticky="nsew", pady=5, padx=(0, 5))
        self.actions_listbox.bind(
            "<<ListboxSelect>>", self._on_action_select_in_listbox
        )  # New handler

        actions_listbox_scrolly = ttk.Scrollbar(
            actions_ui_frame, orient=tk.VERTICAL, command=self.actions_listbox.yview
        )
        actions_listbox_scrolly.grid(
            row=0, column=1, sticky="ns", pady=5
        )  # Attach to column next to listbox
        self.actions_listbox.configure(yscrollcommand=actions_listbox_scrolly.set)

        action_buttons_frame = ttk.Frame(actions_ui_frame)
        action_buttons_frame.grid(
            row=0, column=2, sticky="ns", padx=(5, 0), pady=5
        )  # Buttons to the right of listbox

        self.add_action_button = ttk.Button(
            action_buttons_frame,
            text="Add...",
            command=self._add_action,
            state=tk.DISABLED,
        )
        self.add_action_button.pack(fill=tk.X, pady=2)
        self.edit_action_button = ttk.Button(
            action_buttons_frame,
            text="Edit...",
            command=self._edit_action,
            state=tk.DISABLED,
        )
        self.edit_action_button.pack(fill=tk.X, pady=2)
        self.remove_action_button = ttk.Button(
            action_buttons_frame,
            text="Remove",
            command=self._remove_action,
            state=tk.DISABLED,
        )
        self.remove_action_button.pack(fill=tk.X, pady=2)
        # Move Up/Down buttons can be added later
        # self.move_action_up_button = ttk.Button(action_buttons_frame, text="Up", command=self._move_action_up, state=tk.DISABLED)
        # self.move_action_up_button.pack(fill=tk.X, pady=2)
        # self.move_action_down_button = ttk.Button(action_buttons_frame, text="Down", command=self._move_action_down, state=tk.DISABLED)
        # self.move_action_down_button.pack(fill=tk.X, pady=2)

        bottom_buttons_frame = ttk.Frame(main_frame)
        bottom_buttons_frame.grid(
            row=1, column=0, columnspan=2, sticky="ew", pady=(10, 0)
        )
        bottom_buttons_frame.columnconfigure(0, weight=1)

        self.save_button = ttk.Button(
            bottom_buttons_frame,
            text="Save All Changes",
            command=self._save_all_profiles_to_settings,
            state=tk.NORMAL,
        )
        self.save_button.grid(row=0, column=1, padx=5, pady=5, sticky=tk.E)
        ttk.Button(
            bottom_buttons_frame, text="Close", command=self._on_closing_button
        ).grid(row=0, column=2, padx=5, pady=5, sticky=tk.E)

    def _populate_profiles_listbox(self) -> None:
        self.profiles_listbox.delete(0, tk.END)
        for i, profile in enumerate(self._profiles_data):
            display_name = profile.get("profile_name", f"Unnamed Profile {i+1}")
            self.profiles_listbox.insert(tk.END, display_name)
        self._update_profile_action_buttons_state()

    def _on_profile_select(self, event: Optional[tk.Event] = None) -> None:
        selection_indices = self.profiles_listbox.curselection()
        if not selection_indices:
            self._clear_profile_form()
            self._selected_profile_index = None
            self._update_profile_action_buttons_state()
            self._populate_actions_listbox()  # Clear actions listbox
            return

        new_selected_index = selection_indices[0]

        if (
            self._selected_profile_index is not None
            and self._current_profile_modified_in_form
        ):
            # Only save if the actual profile data would change
            # This check might need to be more robust if comparing complex objects
            current_data_in_form = (
                self._get_data_from_form()
            )  # Hypothetical method to get form data for current profile
            if (
                current_data_in_form
                != self._profiles_data[self._selected_profile_index]
            ):
                if not self._save_current_form_to_profile_data(
                    self._selected_profile_index
                ):
                    # If save failed (e.g. validation), re-select previous to avoid data loss in form
                    self.profiles_listbox.selection_set(self._selected_profile_index)
                    return

        self._select_profile_by_index(new_selected_index)
        self._update_profile_action_buttons_state()

    def _get_data_from_form(self) -> Dict[str, Any]:
        # Helper to get current profile data from form fields (excluding actions for now)
        # Actions are managed directly in self._profiles_data through their editor.
        return {
            "profile_name": self.profile_name_var.get(),
            "target_executable": self.target_exe_var.get(),
            "program_parameters": self.program_params_var.get(),
            # Actions are NOT read from a text widget anymore here.
            # They are part of self._profiles_data[self._selected_profile_index]['actions']
        }

    def _select_profile_by_index(self, index: int) -> None:
        if not (0 <= index < len(self._profiles_data)):
            self._clear_profile_form()
            self._selected_profile_index = None
            return

        self._selected_profile_index = index
        profile = self._profiles_data[index]

        self.profile_name_var.set(profile.get("profile_name", ""))
        self.target_exe_var.set(profile.get("target_executable", ""))
        self.program_params_var.set(profile.get("program_parameters", ""))

        self._populate_actions_listbox()  # NEW: Populate actions list for this profile

        self._enable_profile_form_editing(True)
        self._current_profile_modified_in_form = False

        # Ensure listbox selection matches
        if (
            not self.profiles_listbox.curselection()
            or self.profiles_listbox.curselection()[0] != index
        ):
            self.profiles_listbox.selection_clear(0, tk.END)
            self.profiles_listbox.selection_set(index)
            self.profiles_listbox.activate(index)

        self.add_action_button.config(
            state=tk.NORMAL
        )  # Enable add action if a profile is selected

    def _clear_profile_form(self) -> None:
        self.profile_name_var.set("")
        self.target_exe_var.set("")
        self.program_params_var.set("")

        self._populate_actions_listbox()  # Will clear if no profile selected or profile has no actions

        self._enable_profile_form_editing(False)
        self._current_profile_modified_in_form = False
        self.add_action_button.config(state=tk.DISABLED)
        self.edit_action_button.config(state=tk.DISABLED)
        self.remove_action_button.config(state=tk.DISABLED)

    def _enable_profile_form_editing(self, enable: bool) -> None:
        state = tk.NORMAL if enable else tk.DISABLED
        self.profile_name_entry.config(state=state)
        self.target_exe_entry.config(state=state)
        self.browse_exe_button.config(state=state)
        self.program_params_entry.config(state=state)
        # The actions listbox and its buttons' states are handled by _populate_actions_listbox
        # and _on_action_select_in_listbox

    def _update_profile_action_buttons_state(self) -> None:
        if self._selected_profile_index is not None and self._profiles_data:
            self.duplicate_button.config(state=tk.NORMAL)
            self.delete_button.config(state=tk.NORMAL)
            self.add_action_button.config(
                state=tk.NORMAL
            )  # Enable Add Action if a profile is selected
        else:
            self.duplicate_button.config(state=tk.DISABLED)
            self.delete_button.config(state=tk.DISABLED)
            self.add_action_button.config(state=tk.DISABLED)

    def _browse_target_executable(self) -> None:
        # ... (same as before)
        current_path = self.target_exe_var.get()
        initial_dir = (
            os.path.dirname(current_path)
            if current_path and os.path.exists(os.path.dirname(current_path))
            else None
        )
        path = filedialog.askopenfilename(
            title="Select Target Executable",
            filetypes=[("Executable files", ("*.exe", "*")), ("All files", "*.*")],
            initialdir=initial_dir,
            parent=self,
        )
        if path:
            self.target_exe_var.set(path)
            self._mark_form_as_modified()

    # REMOVED: _validate_current_form_actions_json() - actions are no longer from a JSON text widget

    def _save_current_form_to_profile_data(self, profile_index: int) -> bool:
        if not (0 <= profile_index < len(self._profiles_data)):
            logger.error(f"Invalid profile index {profile_index} for saving form.")
            return False

        profile_name = self.profile_name_var.get().strip()
        if not profile_name:
            messagebox.showerror(
                "Validation Error", "Profile Name cannot be empty.", parent=self
            )
            self.profile_name_entry.focus_set()
            return False

        for i, p_item in enumerate(self._profiles_data):
            if i != profile_index and p_item.get("profile_name") == profile_name:
                messagebox.showerror(
                    "Validation Error",
                    f"Profile name '{profile_name}' already exists.",
                    parent=self,
                )
                self.profile_name_entry.focus_set()
                return False

        # Actions are now part of self._profiles_data[profile_index]["actions"] directly,
        # manipulated by _add_action, _edit_action, _remove_action.
        # No need to parse from a text widget here.

        target_profile = self._profiles_data[profile_index]
        old_name = target_profile.get("profile_name")

        target_profile["profile_name"] = profile_name
        target_profile["target_executable"] = self.target_exe_var.get().strip()
        target_profile["program_parameters"] = self.program_params_var.get()
        # target_profile["actions"] is already up-to-date if actions were modified via their dedicated UI flow.

        self._current_profile_modified_in_form = False
        self._profiles_list_changed_overall = True

        if old_name != profile_name:
            self.profiles_listbox.delete(profile_index)
            self.profiles_listbox.insert(profile_index, profile_name)
            self.profiles_listbox.selection_set(profile_index)

        logger.info(
            f"Profile '{profile_name}' (index {profile_index}) basic details updated in internal list."
        )
        return True

    def _new_profile(self) -> None:
        if (
            self._selected_profile_index is not None
            and self._current_profile_modified_in_form
        ):
            response = messagebox.askyesnocancel(
                "Unsaved Changes",
                f"Profile '{self._profiles_data[self._selected_profile_index].get('profile_name')}' has unsaved changes in the form.\n"
                "Do you want to save them before creating a new profile?",
                default=messagebox.CANCEL,
                parent=self,
            )
            if response is True:  # Yes
                if not self._save_current_form_to_profile_data(
                    self._selected_profile_index
                ):
                    return
            elif response is None:  # Cancel
                return
            # If No, proceed without saving form changes

        new_p_template = DEFAULT_PROFILE.copy()  # Get the template
        new_p = {
            "profile_name": "",  # Will be set
            "target_executable": new_p_template.get("target_executable", ""),
            "program_parameters": new_p_template.get("program_parameters", ""),
            "actions": [],  # Start with no actions; user adds them
        }

        base_name = "New Profile"
        name_candidate = base_name
        count = 1
        existing_names = {p.get("profile_name") for p in self._profiles_data}
        while name_candidate in existing_names:
            name_candidate = f"{base_name} ({count})"
            count += 1
        new_p["profile_name"] = name_candidate

        self._profiles_data.append(new_p)
        self._profiles_list_changed_overall = True
        self._populate_profiles_listbox()
        self._select_profile_by_index(len(self._profiles_data) - 1)
        self.profile_name_entry.focus_set()
        self.profile_name_entry.selection_range(0, tk.END)
        # New profile is inherently "modified" from a saved state perspective.
        # _current_profile_modified_in_form might be set by name_var trace.
        self._mark_form_as_modified()

    def _duplicate_profile(self) -> None:
        # ... (Mostly same, but ensure actions are deep-copied if they are complex) ...
        if self._selected_profile_index is None:
            return

        if self._current_profile_modified_in_form:
            if not self._save_current_form_to_profile_data(
                self._selected_profile_index
            ):
                return

        original_profile = self._profiles_data[self._selected_profile_index]

        duplicated_profile = {
            "profile_name": "",
            "target_executable": original_profile.get("target_executable", ""),
            "program_parameters": original_profile.get("program_parameters", ""),
            # Deep copy of actions list and each action dictionary within it
            "actions": [
                action.copy() for action in original_profile.get("actions", [])
            ],
        }

        base_name = f"{original_profile.get('profile_name', 'Profile')}_copy"
        # ... (rest of unique name generation logic is same)
        name_candidate = base_name
        count = 1
        existing_names = {p.get("profile_name") for p in self._profiles_data}
        while name_candidate in existing_names:
            name_candidate = f"{base_name}_{count}"
            count += 1
        duplicated_profile["profile_name"] = name_candidate

        self._profiles_data.append(duplicated_profile)
        self._profiles_list_changed_overall = True
        self._populate_profiles_listbox()
        self._select_profile_by_index(len(self._profiles_data) - 1)
        self._mark_form_as_modified()

    def _delete_profile(self) -> None:
        # ... (same as before) ...
        if self._selected_profile_index is None or not self._profiles_data:
            return

        profile_to_delete = self._profiles_data[self._selected_profile_index]
        profile_name = profile_to_delete.get("profile_name", "this profile")

        if not messagebox.askyesno(
            "Confirm Delete",
            f"Are you sure you want to delete '{profile_name}'?",
            parent=self,
        ):
            return

        original_selection_index_before_delete = self._selected_profile_index
        del self._profiles_data[original_selection_index_before_delete]
        self._profiles_list_changed_overall = True

        # Adjust selection after deletion
        new_list_size = len(self._profiles_data)
        self._selected_profile_index = None  # Clear old selection index first
        self._populate_profiles_listbox()  # Repopulate before trying to select

        if new_list_size == 0:
            self._clear_profile_form()
        else:
            # Try to select the item that was at the same index, or the last item if out of bounds
            new_selection_idx = min(
                original_selection_index_before_delete, new_list_size - 1
            )
            self._select_profile_by_index(new_selection_idx)

    def _save_all_profiles_to_settings(self) -> None:
        if (
            self._selected_profile_index is not None
            and self._current_profile_modified_in_form
        ):
            if not self._save_current_form_to_profile_data(
                self._selected_profile_index
            ):
                messagebox.showerror(
                    "Save Error",
                    "Could not save changes from the form for the selected profile. Aborting save to settings.",
                    parent=self,
                )
                return

        profile_names_seen = set()
        for i, profile in enumerate(self._profiles_data):
            name = profile.get("profile_name", "").strip()
            if not name:
                messagebox.showerror(
                    "Validation Error",
                    f"Profile at index {i} (try selecting it) has an empty name. Please provide a name.",
                    parent=self,
                )
                # Try to select it for the user to fix
                if self.profiles_listbox.size() > i:
                    self._select_profile_by_index(i)
                return
            if name in profile_names_seen:
                messagebox.showerror(
                    "Validation Error",
                    f"Duplicate profile name '{name}' found. Profile names must be unique.",
                    parent=self,
                )
                if self.profiles_listbox.size() > i:
                    self._select_profile_by_index(i)
                return
            profile_names_seen.add(name)

            # Validate actions within each profile (basic check: must be a list of dicts)
            actions = profile.get("actions")
            if not isinstance(actions, list):
                messagebox.showerror(
                    "Data Error",
                    f"Profile '{name}' has malformed actions (not a list). Please correct.",
                    parent=self,
                )
                if self.profiles_listbox.size() > i:
                    self._select_profile_by_index(i)
                return
            for idx, action in enumerate(actions):
                if not isinstance(action, dict):
                    messagebox.showerror(
                        "Data Error",
                        f"Profile '{name}', action {idx+1} is malformed (not a dictionary). Please correct.",
                        parent=self,
                    )
                    if self.profiles_listbox.size() > i:
                        self._select_profile_by_index(i)
                    return
                # Could add more specific action validation here if ActionEditor is not fully trusted yet

        self.app_settings.set_profiles(self._profiles_data)
        if self.app_settings.save_settings():
            logger.info(
                f"All {len(self._profiles_data)} profiles saved to AppSettings."
            )
            messagebox.showinfo(
                "Profiles Saved", "All profile changes have been saved.", parent=self
            )
            self._current_profile_modified_in_form = False
            self._profiles_list_changed_overall = False
        else:
            messagebox.showerror(
                "Save Error",
                "Could not save profiles to the settings file. Check logs.",
                parent=self,
            )

    def _on_closing_button(self) -> None:
        # ... (same logic as before, using _current_profile_modified_in_form and _profiles_list_changed_overall)
        needs_save_prompt = False
        prompt_message = ""

        if (
            self._selected_profile_index is not None
            and self._current_profile_modified_in_form
        ):
            needs_save_prompt = True
            profile_name = self._profiles_data[self._selected_profile_index].get(
                "profile_name", "current profile"
            )
            prompt_message = (
                f"Profile '{profile_name}' has unsaved changes in the form.\n"
            )

        if (
            self._profiles_list_changed_overall and not needs_save_prompt
        ):  # Only check overall if form isn't already prompting
            needs_save_prompt = True
            prompt_message = "The list of profiles (additions, deletions, or saved edits) has changed.\n"
        elif (
            self._profiles_list_changed_overall and needs_save_prompt
        ):  # Both have changes
            prompt_message += (
                "Additionally, the overall list of profiles has changed.\n"
            )

        if needs_save_prompt:
            prompt_message += "Do you want to save all changes before closing?"
            response = messagebox.askyesnocancel(
                "Unsaved Changes",
                prompt_message,
                default=messagebox.CANCEL,
                parent=self,
            )
            if response is True:  # Yes
                self._save_all_profiles_to_settings()
                # If save failed, _save_all_profiles_to_settings shows message, we still proceed to close
            elif response is None:  # Cancel
                return
            # If False (No), proceed to close without saving

        self.parent_window.focus_set()
        self.destroy()

    # --- NEW Methods for Actions Management ---
    def _populate_actions_listbox(self) -> None:
        """Populates the actions listbox for the currently selected profile."""
        self.actions_listbox.delete(0, tk.END)
        self._selected_action_index_in_profile = None  # Reset action selection

        if (
            self._selected_profile_index is not None
            and 0 <= self._selected_profile_index < len(self._profiles_data)
        ):
            profile = self._profiles_data[self._selected_profile_index]
            actions = profile.get("actions", [])
            for i, action in enumerate(actions):
                # Display a summary of the action. Customize as needed.
                bp = action.get("breakpoint_location", "N/A")
                num_vars = len(action.get("variables_to_dump", []))
                fmt = action.get("output_format", "N/A")
                cont = "Yes" if action.get("continue_after_dump", False) else "No"
                summary = f"BP: {bp} (Vars: {num_vars}, Fmt: {fmt}, Cont: {cont})"
                self.actions_listbox.insert(tk.END, summary)

        self._update_action_buttons_state()  # Update Edit/Remove based on selection

    def _on_action_select_in_listbox(self, event: Optional[tk.Event] = None) -> None:
        """Handles selection of an action in the actions_listbox."""
        selection_indices = self.actions_listbox.curselection()
        if selection_indices:
            self._selected_action_index_in_profile = selection_indices[0]
        else:
            self._selected_action_index_in_profile = None
        self._update_action_buttons_state()

    def _update_action_buttons_state(self) -> None:
        """Updates the state of Edit and Remove action buttons."""
        profile_selected = self._selected_profile_index is not None
        action_selected = self._selected_action_index_in_profile is not None

        self.add_action_button.config(
            state=tk.NORMAL if profile_selected else tk.DISABLED
        )
        self.edit_action_button.config(
            state=tk.NORMAL if action_selected else tk.DISABLED
        )
        self.remove_action_button.config(
            state=tk.NORMAL if action_selected else tk.DISABLED
        )
        # self.move_action_up_button.config(state=tk.NORMAL if action_selected and self._selected_action_index_in_profile > 0 else tk.DISABLED)
        # num_actions = 0
        # if profile_selected and "actions" in self._profiles_data[self._selected_profile_index]:
        #     num_actions = len(self._profiles_data[self._selected_profile_index]["actions"])
        # self.move_action_down_button.config(state=tk.NORMAL if action_selected and self._selected_action_index_in_profile < (num_actions -1) else tk.DISABLED)

    def _add_action(self) -> None:
        if self._selected_profile_index is None:
            return

        editor = ActionEditorWindow(
            self, action_data=None, is_new=True
        )  # Pass self (ProfileManagerWindow) as parent
        new_action_data = editor.get_result()

        if new_action_data:
            profile = self._profiles_data[self._selected_profile_index]
            if "actions" not in profile or not isinstance(profile["actions"], list):
                profile["actions"] = []  # Ensure actions list exists
            profile["actions"].append(new_action_data)

            self._profiles_list_changed_overall = True  # Mark profile as changed
            self._current_profile_modified_in_form = (
                True  # This profile in form has changed
            )
            self._populate_actions_listbox()  # Refresh actions list
            self.actions_listbox.selection_set(tk.END)  # Select the new action
            self._on_action_select_in_listbox()  # Update button states
            logger.info(f"Added new action to profile '{profile.get('profile_name')}'.")

    def _edit_action(self) -> None:
        if (
            self._selected_profile_index is None
            or self._selected_action_index_in_profile is None
        ):
            logger.warning("Edit action called but no profile or action is selected.")
            return

        # Ensure the selected action index is valid for the current actions list
        profile = self._profiles_data[self._selected_profile_index]
        actions_list = profile.get("actions", [])

        # Defensive check for the selected action index
        if not (0 <= self._selected_action_index_in_profile < len(actions_list)):
            logger.error(
                f"Selected action index {self._selected_action_index_in_profile} is out of bounds for actions list of length {len(actions_list)}."
            )
            self._selected_action_index_in_profile = None  # Invalidate selection
            self._update_action_buttons_state()  # Update UI
            messagebox.showerror(
                "Error",
                "The selected action index is no longer valid. Please re-select.",
                parent=self,
            )
            return

        action_to_edit = actions_list[self._selected_action_index_in_profile]

        editor = ActionEditorWindow(self, action_data=action_to_edit, is_new=False)
        updated_action_data = editor.get_result()

        if updated_action_data:
            profile["actions"][
                self._selected_action_index_in_profile
            ] = updated_action_data

            self._profiles_list_changed_overall = True
            self._current_profile_modified_in_form = (
                True  # Mark profile as changed because an action within it changed
            )

            # Store the current selection index because _populate_actions_listbox clears it
            current_action_idx_to_reselect = self._selected_action_index_in_profile

            self._populate_actions_listbox()  # Refresh to show updated summary

            # MODIFIED: Ensure re-selection is valid
            if (
                current_action_idx_to_reselect is not None
                and 0 <= current_action_idx_to_reselect < self.actions_listbox.size()
            ):
                self.actions_listbox.selection_set(current_action_idx_to_reselect)

            self._on_action_select_in_listbox()  # This will correctly set _selected_action_index_in_profile based on actual listbox selection
            logger.info(f"Edited action in profile '{profile.get('profile_name')}'.")
        else:
            # If editor was cancelled, ensure the original selection state is maintained or cleared if necessary
            # No, _on_action_select_in_listbox() will handle this if we re-select.
            # If editor was cancelled, the selection in listbox shouldn't change from user's perspective
            # unless the list itself was repopulated for other reasons.
            # Let's ensure the listbox selection status is re-evaluated by _on_action_select_in_listbox
            self._on_action_select_in_listbox()  # Call to ensure button states are correct after editor close
            pass

    def _remove_action(self) -> None:
        if (
            self._selected_profile_index is None
            or self._selected_action_index_in_profile is None
        ):
            return

        profile = self._profiles_data[self._selected_profile_index]
        action_summary_to_delete = self.actions_listbox.get(
            self._selected_action_index_in_profile
        )

        if not messagebox.askyesno(
            "Confirm Delete Action",
            f"Are you sure you want to delete this action?\n\n{action_summary_to_delete}",
            parent=self,
        ):
            return

        del profile.get("actions", [])[self._selected_action_index_in_profile]

        self._profiles_list_changed_overall = True
        self._current_profile_modified_in_form = True
        self._populate_actions_listbox()  # Refresh
        # Try to select the next item or previous if last was deleted
        num_actions = len(profile.get("actions", []))
        if num_actions > 0:
            new_selection = min(self._selected_action_index_in_profile, num_actions - 1)
            if new_selection >= 0:
                self.actions_listbox.selection_set(new_selection)
        self._on_action_select_in_listbox()  # Update button states