# File: cpp_python_debug/gui/main_window.py
# Provides the Tkinter GUI for interacting with the GDB session and automated profiles.

import tkinter as tk
from tkinter import filedialog, messagebox, ttk, scrolledtext, Menu
import logging
import os
import json
import re
import threading
import subprocess
import sys
import shutil 
from datetime import datetime
from typing import (
    Optional,
    Dict,
    Any,
    Callable,
    List,
    Tuple,
)

from ..core.gdb_controller import GDBSession
from ..core.output_formatter import save_to_json, save_to_csv
from ..core.config_manager import AppSettings
from ..core.profile_executor import (
    ProfileExecutor, # Still needed for type hints and its constants if used
    ExecutionLogEntry,
    GDB_DUMP_EXTENSION, 
    sanitize_filename_component 
)
from .config_window import ConfigWindow
from .profile_manager_window import ProfileManagerWindow

logger = logging.getLogger(__name__)

try:
    from cpp_python_debug import _version as wrapper_version
    WRAPPER_APP_VERSION_STRING = f"{wrapper_version.__version__} ({wrapper_version.GIT_BRANCH}/{wrapper_version.GIT_COMMIT_HASH[:7]})"
    WRAPPER_BUILD_INFO = f"Wrapper Built: {wrapper_version.BUILD_TIMESTAMP}"
except ImportError:
    WRAPPER_APP_VERSION_STRING = "(Dev Wrapper)"
    WRAPPER_BUILD_INFO = "Wrapper build time unknown"

MANUAL_DUMP_PROFILE_NAME_PLACEHOLDER = "ManualDump"
MANUAL_DUMP_FILENAME_PATTERN = "{profile_name}_{app_name}_{breakpoint}_{variable}_{timestamp}{extension}" # Added app_name
MANUAL_DUMPS_SUBFOLDER = "manual_gdb_dumps"


class GDBGui(tk.Tk):
    def __init__(self):
        super().__init__()

        self.app_settings = AppSettings()
        self.gui_log_handler: Optional[ScrolledTextLogHandler] = None

        self.title(
            f"GDB Debug GUI - {WRAPPER_APP_VERSION_STRING} - Settings: {os.path.basename(self.app_settings.config_filepath)} "
        )
        self.geometry(
            self.app_settings.get_setting("gui", "main_window_geometry", "850x800") 
        )

        self.gdb_session: Optional[GDBSession] = None
        self.last_manual_gdb_dump_filepath: Optional[str] = None
        self.program_started_once: bool = False

        self.gdb_exe_status_var = tk.StringVar(value="GDB: Checking...")
        self.gdb_dumper_status_var = tk.StringVar(value="Dumper Script: Checking...")

        self.exe_path_var = tk.StringVar(value=self.app_settings.get_setting("general", "last_target_executable_path", ""))
        self.breakpoint_var = tk.StringVar(value=self.app_settings.get_setting("general", "default_breakpoint", "main"))
        self.variable_var = tk.StringVar(value=self.app_settings.get_setting("general", "default_variable_to_dump", ""))
        self.params_var = tk.StringVar(value=self.app_settings.get_setting("general", "default_program_parameters", ""))

        self.profile_executor_instance: Optional[ProfileExecutor] = None
        self.available_profiles_map: Dict[str, Dict[str, Any]] = {}
        self.profile_exec_status_var = tk.StringVar(value="Select a profile to run.")
        self.produced_files_tree: Optional[ttk.Treeview] = None
        self.last_run_output_path: Optional[str] = None 
        self.manual_dumps_output_path: Optional[str] = None 
        self.profile_progressbar: Optional[ttk.Progressbar] = None
        self.status_bar_widget: Optional[ttk.Label] = None
        self.status_var: Optional[tk.StringVar] = None

        # MODIFICA: Chiamare _prepare_manual_dumps_directory PRIMA di _create_widgets
        self._prepare_manual_dumps_directory() 

        self._create_menus()
        self._create_widgets() # Ora _populate_manual_debug_tab avrà self.manual_dumps_output_path già impostato
        self._setup_logging_redirect_to_gui()
        self._check_critical_configs_and_update_gui()
        self._load_and_populate_profiles_for_automation_tab()
        # self._prepare_manual_dumps_directory() # Rimosso da qui

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

    def _prepare_manual_dumps_directory(self):
        # ... (implementazione come prima, ma ora viene chiamata prima) ...
        base_dir = self.app_settings.config_dir 
        self.manual_dumps_output_path = os.path.join(base_dir, MANUAL_DUMPS_SUBFOLDER)
        try:
            os.makedirs(self.manual_dumps_output_path, exist_ok=True)
            logger.info(f"Manual dumps directory ensured: {self.manual_dumps_output_path}")
            # Se il pulsante esiste già e la directory è stata creata/confermata, abilitalo
            if hasattr(self, 'open_manual_dumps_folder_button') and self.open_manual_dumps_folder_button:
                self.open_manual_dumps_folder_button.config(state=tk.NORMAL)
        except OSError as e:
            logger.error(f"Could not create manual dumps directory '{self.manual_dumps_output_path}': {e}")
            self.manual_dumps_output_path = None 
            if hasattr(self, 'open_manual_dumps_folder_button') and self.open_manual_dumps_folder_button:
                self.open_manual_dumps_folder_button.config(state=tk.DISABLED)
            # Non mostrare messagebox qui perché potrebbe essere chiamato prima che la GUI principale sia pronta
            # Lo stato del pulsante rifletterà il successo o fallimento.

    def _create_menus(self): # Unchanged
        self.menubar = Menu(self); self.config(menu=self.menubar)
        options_menu = Menu(self.menubar, tearoff=0); self.menubar.add_cascade(label="Options", menu=options_menu)
        options_menu.add_command(label="Configure Application...", command=self._open_config_window)
        options_menu.add_separator(); options_menu.add_command(label="Exit", command=self._on_closing_window)
        profiles_menu = Menu(self.menubar, tearoff=0); self.menubar.add_cascade(label="Profiles", menu=profiles_menu)
        profiles_menu.add_command(label="Manage Profiles...", command=self._open_profile_manager_window)

    def _open_config_window(self): # Unchanged
        logger.debug("Opening configuration window.")
        config_win = ConfigWindow(self, self.app_settings); self.wait_window(config_win)
        logger.debug("Configuration window closed."); self._check_critical_configs_and_update_gui()
        self._prepare_manual_dumps_directory() 

    def _open_profile_manager_window(self): # Unchanged
        logger.info("Opening Profile Manager window.")
        profile_win = ProfileManagerWindow(self, self.app_settings); self.wait_window(profile_win)
        logger.info("Profile Manager window closed."); self._load_and_populate_profiles_for_automation_tab()

    def _check_critical_configs_and_update_gui(self): # Unchanged
        logger.info("Checking critical configurations..."); gdb_exe_path = self.app_settings.get_setting("general", "gdb_executable_path")
        dumper_script_path = self.app_settings.get_setting("general", "gdb_dumper_script_path"); gdb_ok = False
        if gdb_exe_path and os.path.isfile(gdb_exe_path): self.gdb_exe_status_var.set(f"GDB: {os.path.basename(gdb_exe_path)} (OK)"); gdb_ok = True
        elif gdb_exe_path: self.gdb_exe_status_var.set(f"GDB: '{gdb_exe_path}' (Not Found/Invalid!)")
        else: self.gdb_exe_status_var.set("GDB: Not Configured! Set in Options > Configure.")
        if dumper_script_path and os.path.isfile(dumper_script_path): self.gdb_dumper_status_var.set(f"Dumper: {os.path.basename(dumper_script_path)} (OK)")
        elif dumper_script_path: self.gdb_dumper_status_var.set(f"Dumper: '{dumper_script_path}' (Not Found/Invalid!)")
        else: self.gdb_dumper_status_var.set("Dumper: Not Configured (Optional).")
        if hasattr(self, "start_gdb_button"):
            if gdb_ok and not (self.profile_executor_instance and self.profile_executor_instance.is_running): self.start_gdb_button.config(state=tk.NORMAL)
            else: self.start_gdb_button.config(state=tk.DISABLED)
        if not gdb_ok: self._reset_gui_to_stopped_state()
        self.title(f"GDB Debug GUI - {WRAPPER_APP_VERSION_STRING} - Settings: {os.path.basename(self.app_settings.config_filepath)}")

    def _create_widgets(self): # Unchanged
        main_frame = ttk.Frame(self, padding="10"); main_frame.grid(row=0, column=0, sticky="nsew")
        self.columnconfigure(0, weight=1); self.rowconfigure(0, weight=1)
        main_frame.rowconfigure(0, weight=0); main_frame.rowconfigure(1, weight=1); main_frame.rowconfigure(2, weight=8); main_frame.rowconfigure(3, weight=0); main_frame.columnconfigure(0, weight=1)
        self._create_config_status_widgets(main_frame); self._create_mode_notebook_widgets(main_frame); self._create_output_log_widgets(main_frame); self._create_status_bar(main_frame)

    def _create_config_status_widgets(self, parent_frame: ttk.Frame): # Unchanged
        config_status_frame = ttk.LabelFrame(parent_frame, text="Critical Configuration Status", padding=(10,5,10,10)); config_status_frame.grid(row=0, column=0, sticky="ew", pady=5, padx=0)
        config_status_frame.columnconfigure(1, weight=1); config_status_frame.columnconfigure(3, weight=1)
        ttk.Label(config_status_frame, text="GDB:").grid(row=0, column=0, sticky=tk.W, padx=(5,0), pady=5)
        self.gdb_exe_status_label = ttk.Label(config_status_frame, textvariable=self.gdb_exe_status_var, relief="sunken", padding=(5,2), anchor=tk.W); self.gdb_exe_status_label.grid(row=0, column=1, sticky="ew", padx=(0,10), pady=5)
        ttk.Label(config_status_frame, text="Dumper:").grid(row=0, column=2, sticky=tk.W, padx=(5,0), pady=5)
        self.gdb_dumper_status_label = ttk.Label(config_status_frame, textvariable=self.gdb_dumper_status_var, relief="sunken", padding=(5,2), anchor=tk.W); self.gdb_dumper_status_label.grid(row=0, column=3, sticky="ew", padx=(0,10), pady=5)
        ttk.Button(config_status_frame, text="Configure...", command=self._open_config_window).grid(row=0, column=4, padx=(5,5), pady=5, sticky=tk.E)

    def _create_mode_notebook_widgets(self, parent_frame: ttk.Frame): # Unchanged
        mode_notebook = ttk.Notebook(parent_frame); mode_notebook.grid(row=1, column=0, columnspan=1, sticky="nsew", pady=5, padx=0)
        manual_debug_frame = ttk.Frame(mode_notebook, padding="5"); mode_notebook.add(manual_debug_frame, text="Manual Debug"); self._populate_manual_debug_tab(manual_debug_frame)
        self.automated_exec_frame = ttk.Frame(mode_notebook, padding="10"); mode_notebook.add(self.automated_exec_frame, text="Automated Profile Execution"); self._populate_automated_execution_tab(self.automated_exec_frame) # type: ignore

    def _populate_manual_debug_tab(self, parent_tab_frame: ttk.Frame):
        parent_tab_frame.columnconfigure(0, weight=1)

        manual_target_settings_frame = ttk.LabelFrame(parent_tab_frame, text="Target & Debug Session Settings", padding="10")
        manual_target_settings_frame.grid(row=0, column=0, sticky="ew", pady=5)
        manual_target_settings_frame.columnconfigure(1, weight=1)
        row_idx = 0
        # ... (campi Target, Params, Breakpoint, Variable come prima) ...
        ttk.Label(manual_target_settings_frame, text="Target Executable:").grid(row=row_idx, column=0, sticky=tk.W, padx=5, pady=2)
        ttk.Entry(manual_target_settings_frame, textvariable=self.exe_path_var, width=70).grid(row=row_idx, column=1, sticky="ew", padx=5, pady=2)
        ttk.Button(manual_target_settings_frame, text="Browse...", command=self._browse_target_exe).grid(row=row_idx, column=2, padx=5, pady=2); row_idx += 1
        ttk.Label(manual_target_settings_frame, text="Program Parameters:").grid(row=row_idx, column=0, sticky=tk.W, padx=5, pady=2)
        ttk.Entry(manual_target_settings_frame, textvariable=self.params_var).grid(row=row_idx, column=1, columnspan=2, sticky="ew", padx=5, pady=2); row_idx += 1
        ttk.Label(manual_target_settings_frame, text="Breakpoint Location:").grid(row=row_idx, column=0, sticky=tk.W, padx=5, pady=2)
        ttk.Entry(manual_target_settings_frame, textvariable=self.breakpoint_var).grid(row=row_idx, column=1, columnspan=2, sticky="ew", padx=5, pady=2); row_idx += 1
        ttk.Label(manual_target_settings_frame, text="Examples: main, file.cpp:123", foreground="gray", font=("TkDefaultFont", 8)).grid(row=row_idx, column=1, columnspan=2, sticky=tk.W, padx=7, pady=(0,5)); row_idx += 1
        ttk.Label(manual_target_settings_frame, text="Variable/Expression:").grid(row=row_idx, column=0, sticky=tk.W, padx=5, pady=2)
        ttk.Entry(manual_target_settings_frame, textvariable=self.variable_var).grid(row=row_idx, column=1, columnspan=2, sticky="ew", padx=5, pady=2)


        manual_session_control_frame = ttk.LabelFrame(parent_tab_frame, text="Session Control", padding="10")
        manual_session_control_frame.grid(row=1, column=0, sticky="ew", pady=(10,5))
        button_flow_frame = ttk.Frame(manual_session_control_frame); button_flow_frame.pack(fill=tk.X, expand=True)
        # ... (pulsanti Start GDB, Set BP, Run, Dump Var, Stop GDB come prima) ...
        self.start_gdb_button = ttk.Button(button_flow_frame, text="1. Start GDB", command=self._start_gdb_session_action, state=tk.DISABLED); self.start_gdb_button.pack(side=tk.LEFT, padx=2, pady=5, fill=tk.X, expand=True)
        self.set_bp_button = ttk.Button(button_flow_frame, text="2. Set BP", command=self._set_gdb_breakpoint_action, state=tk.DISABLED); self.set_bp_button.pack(side=tk.LEFT, padx=2, pady=5, fill=tk.X, expand=True)
        self.run_button = ttk.Button(button_flow_frame, text="3. Run", command=self._run_or_continue_gdb_action, state=tk.DISABLED); self.run_button.pack(side=tk.LEFT, padx=2, pady=5, fill=tk.X, expand=True)
        self.dump_var_button = ttk.Button(button_flow_frame, text="4. Dump Var", command=self._dump_gdb_variable_action, state=tk.DISABLED); self.dump_var_button.pack(side=tk.LEFT, padx=2, pady=5, fill=tk.X, expand=True)
        self.stop_gdb_button = ttk.Button(button_flow_frame, text="Stop GDB", command=self._stop_gdb_session_action, state=tk.DISABLED); self.stop_gdb_button.pack(side=tk.LEFT, padx=2, pady=5, fill=tk.X, expand=True)
        
        manual_save_data_frame = ttk.LabelFrame(parent_tab_frame, text="Save/Manage Dumped Data", padding="10")
        manual_save_data_frame.grid(row=2, column=0, sticky="ew", pady=5)

        self.save_json_button = ttk.Button(manual_save_data_frame, text="Save as JSON", command=lambda: self._save_dumped_data("json"), state=tk.DISABLED)
        self.save_json_button.pack(side=tk.LEFT, padx=5, pady=5)
        self.save_csv_button = ttk.Button(manual_save_data_frame, text="Save as CSV", command=lambda: self._save_dumped_data("csv"), state=tk.DISABLED)
        self.save_csv_button.pack(side=tk.LEFT, padx=5, pady=5)
        
        # MODIFICA: Lo stato iniziale del pulsante dipende da self.manual_dumps_output_path
        # che ora dovrebbe essere impostato correttamente prima che questo metodo venga chiamato.
        self.open_manual_dumps_folder_button = ttk.Button(
            manual_save_data_frame, 
            text="Open Dumps Folder", 
            command=self._open_manual_dumps_folder, 
            state=(tk.NORMAL if self.manual_dumps_output_path else tk.DISABLED)
        )
        self.open_manual_dumps_folder_button.pack(side=tk.LEFT, padx=5, pady=5)

    def _populate_automated_execution_tab(self, parent_tab_frame: ttk.Frame) -> None: # Unchanged
        parent_tab_frame.columnconfigure(0, weight=1); parent_tab_frame.rowconfigure(0, weight=0); parent_tab_frame.rowconfigure(1, weight=0); parent_tab_frame.rowconfigure(2, weight=1); parent_tab_frame.rowconfigure(3, weight=0)
        auto_control_frame = ttk.LabelFrame(parent_tab_frame, text="Profile Execution Control", padding="10"); auto_control_frame.grid(row=0, column=0, sticky="ew", pady=5); auto_control_frame.columnconfigure(1, weight=1)
        ttk.Label(auto_control_frame, text="Select Profile:").grid(row=0, column=0, padx=(5,2), pady=5, sticky="w")
        self.profile_selection_combo = ttk.Combobox(auto_control_frame, state="readonly", width=35, textvariable=tk.StringVar()); self.profile_selection_combo.grid(row=0, column=1, padx=(0,5), pady=5, sticky="ew")
        self.run_profile_button = ttk.Button(auto_control_frame, text="Run Profile", command=self._run_selected_profile_action, state=tk.DISABLED); self.run_profile_button.grid(row=0, column=2, padx=(0,2), pady=5, sticky="ew")
        self.stop_profile_button = ttk.Button(auto_control_frame, text="Stop Profile", command=self._stop_current_profile_action, state=tk.DISABLED); self.stop_profile_button.grid(row=0, column=3, padx=(0,5), pady=5, sticky="ew")
        progress_status_frame = ttk.Frame(parent_tab_frame); progress_status_frame.grid(row=1, column=0, sticky="ew", pady=(5,0)); progress_status_frame.columnconfigure(0, weight=1); progress_status_frame.rowconfigure(0, weight=1); progress_status_frame.rowconfigure(1, weight=0)
        self.profile_exec_status_label_big = ttk.Label(progress_status_frame, textvariable=self.profile_exec_status_var, font=("TkDefaultFont", 10, "bold"), anchor=tk.NW, justify=tk.LEFT); self.profile_exec_status_label_big.grid(row=0, column=0, sticky="new", padx=5, pady=(0,2))
        def _configure_wraplength_for_status_label(event):
            new_width = event.width - 15
            if new_width > 20 and hasattr(self, 'profile_exec_status_label_big') and self.profile_exec_status_label_big.winfo_exists(): self.profile_exec_status_label_big.config(wraplength=new_width)
        progress_status_frame.bind("<Configure>", _configure_wraplength_for_status_label)
        self.profile_progressbar = ttk.Progressbar(progress_status_frame, orient=tk.HORIZONTAL, mode='indeterminate')
        produced_files_frame = ttk.LabelFrame(parent_tab_frame, text="Produced Files Log", padding="10"); produced_files_frame.grid(row=2, column=0, sticky="nsew", pady=(5,0)); produced_files_frame.columnconfigure(0, weight=1); produced_files_frame.rowconfigure(0, weight=1)
        self.produced_files_tree = ttk.Treeview(produced_files_frame, columns=("timestamp", "breakpoint_spec", "variable", "file", "status", "details"), show="headings", selectmode="browse"); self.produced_files_tree.grid(row=0, column=0, sticky="nsew")
        headings = {"timestamp": "Time", "breakpoint_spec": "Breakpoint Spec", "variable": "Variable", "file": "File Produced", "status": "Status", "details": "Details"}
        widths = {"timestamp": 130, "breakpoint_spec": 150, "variable": 150, "file": 180, "status": 80, "details": 180}
        minwidths = {"timestamp": 120, "breakpoint_spec": 100, "variable": 100, "file": 150, "status": 60, "details": 150}
        stretches = {"timestamp": False, "breakpoint_spec": True, "variable": True, "file": True, "status": False, "details": True}
        for col, text in headings.items(): self.produced_files_tree.heading(col, text=text, anchor=tk.W); self.produced_files_tree.column(col, width=widths[col], minwidth=minwidths[col], stretch=stretches[col])
        tree_scrollbar_y = ttk.Scrollbar(produced_files_frame, orient=tk.VERTICAL, command=self.produced_files_tree.yview); tree_scrollbar_y.grid(row=0, column=1, sticky="ns")
        tree_scrollbar_x = ttk.Scrollbar(produced_files_frame, orient=tk.HORIZONTAL, command=self.produced_files_tree.xview); tree_scrollbar_x.grid(row=1, column=0, sticky="ew")
        self.produced_files_tree.configure(yscrollcommand=tree_scrollbar_y.set, xscrollcommand=tree_scrollbar_x.set)
        folder_button_frame = ttk.Frame(parent_tab_frame); folder_button_frame.grid(row=3, column=0, sticky="e", pady=(5,0))
        self.open_output_folder_button = ttk.Button(folder_button_frame, text="Open Profile Output Folder", command=self._open_last_run_output_folder, state=tk.DISABLED); self.open_output_folder_button.pack(side=tk.RIGHT, padx=5, pady=0)

    def _load_and_populate_profiles_for_automation_tab(self): # Unchanged
        self.available_profiles_map.clear(); profiles_list = self.app_settings.get_profiles(); profile_display_names = []
        for profile_item in profiles_list: 
            name = profile_item.get("profile_name"); 
            if name: self.available_profiles_map[name] = profile_item; 
            profile_display_names.append(name)
        sorted_names = sorted(profile_display_names); self.profile_selection_combo["values"] = sorted_names
        if sorted_names: 
            self.profile_selection_combo.set(sorted_names[0]); 
            if not (self.profile_executor_instance and self.profile_executor_instance.is_running): self.run_profile_button.config(state=tk.NORMAL)
            self.profile_exec_status_var.set(f"Ready to run profile: {self.profile_selection_combo.get()}")
        else: self.profile_selection_combo.set(""); self.run_profile_button.config(state=tk.DISABLED); self.profile_exec_status_var.set("No profiles. Create via 'Profiles > Manage'.")

    def _create_output_log_widgets(self, parent_frame: ttk.Frame): # Unchanged
        output_log_notebook = ttk.Notebook(parent_frame); output_log_notebook.grid(row=2, column=0, columnspan=1, sticky="nsew", pady=(5,0), padx=0)
        log_text_height = 12 
        self.gdb_raw_output_text = scrolledtext.ScrolledText(output_log_notebook, wrap=tk.WORD, height=log_text_height, state=tk.DISABLED, font=("Consolas", 9)); output_log_notebook.add(self.gdb_raw_output_text, text="GDB Raw Output")
        self.parsed_json_output_text = scrolledtext.ScrolledText(output_log_notebook, wrap=tk.WORD, height=log_text_height, state=tk.DISABLED, font=("Consolas", 9)); output_log_notebook.add(self.parsed_json_output_text, text="Parsed JSON/Status Output")
        self.app_log_text = scrolledtext.ScrolledText(output_log_notebook, wrap=tk.WORD, height=log_text_height, state=tk.DISABLED, font=("Consolas", 9)); output_log_notebook.add(self.app_log_text, text="Application Log")

    def _create_status_bar(self, parent_frame: ttk.Frame): # Unchanged
        self.status_var = tk.StringVar(value="Ready."); self.status_bar_widget = ttk.Label(parent_frame, textvariable=self.status_var, relief=tk.SUNKEN, anchor=tk.W)
        self.status_bar_widget.grid(row=3, column=0, columnspan=1, sticky="ew", pady=(5,0), ipady=2, padx=0)

    def _setup_logging_redirect_to_gui(self): # Unchanged
        if not hasattr(self, "app_log_text") or not self.app_log_text: logger.error("app_log_text not found."); return
        self.gui_log_handler = ScrolledTextLogHandler(self.app_log_text); formatter = logging.Formatter('%(asctime)s [%(levelname)-7s] %(name)s: %(message)s', datefmt='%H:%M:%S')
        self.gui_log_handler.setFormatter(formatter); self.gui_log_handler.setLevel(logging.INFO); logging.getLogger().addHandler(self.gui_log_handler)

    def _browse_file(self, title: str, target_var: tk.StringVar, filetypes: Optional[List[Tuple[str, Any]]]=None): # Unchanged
        current_path = target_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=title, filetypes=filetypes or [("All files", "*.*")], initialdir=initial_dir, parent=self)
        if path: target_var.set(path)

    def _browse_target_exe(self): self._browse_file("Select Target Executable", self.exe_path_var, [("Executable files", ("*.exe", "*")), ("All files", "*.*")]) # Unchanged

    def _update_gdb_raw_output(self, text: str, append: bool = True): # Unchanged
        if not hasattr(self, "gdb_raw_output_text") or not self.gdb_raw_output_text.winfo_exists(): return
        self.gdb_raw_output_text.config(state=tk.NORMAL)
        if append: self.gdb_raw_output_text.insert(tk.END, str(text) + "\n")
        else: self.gdb_raw_output_text.delete("1.0", tk.END); self.gdb_raw_output_text.insert("1.0", str(text))
        self.gdb_raw_output_text.see(tk.END); self.gdb_raw_output_text.config(state=tk.DISABLED)

    def _update_parsed_json_output(self, data_to_display: Any): # Unchanged (handles status payload)
        if not hasattr(self, "parsed_json_output_text") or not self.parsed_json_output_text.winfo_exists(): return
        self.parsed_json_output_text.config(state=tk.NORMAL); self.parsed_json_output_text.delete("1.0", tk.END)
        if data_to_display is None: self.parsed_json_output_text.insert("1.0", "<No data>")
        elif isinstance(data_to_display, dict):
            if "status" in data_to_display and ("filepath_written" in data_to_display or "message" in data_to_display):
                status_text = f"Status: {data_to_display.get('status', 'N/A')}\nVar: {data_to_display.get('variable_dumped', 'N/A')}\n" \
                              f"File: {data_to_display.get('filepath_written', 'N/A')}\nFmt Req: {data_to_display.get('target_format_requested', 'N/A')}\n" \
                              f"Msg: {data_to_display.get('message', 'N/A')}\n"
                if data_to_display.get("details"): status_text += f"Details: {data_to_display.get('details')}\n"
                self.parsed_json_output_text.insert("1.0", status_text)
            else: 
                try: self.parsed_json_output_text.insert("1.0", json.dumps(data_to_display, indent=2, ensure_ascii=False))
                except Exception as e: self.parsed_json_output_text.insert("1.0", f"Err JSON: {e}\nRaw: {str(data_to_display)}")
        elif isinstance(data_to_display, list): 
             try: self.parsed_json_output_text.insert("1.0", json.dumps(data_to_display, indent=2, ensure_ascii=False))
             except Exception as e: self.parsed_json_output_text.insert("1.0", f"Err list: {e}\nRaw: {str(data_to_display)}")
        else: self.parsed_json_output_text.insert("1.0", str(data_to_display))
        self.parsed_json_output_text.see("1.0"); self.parsed_json_output_text.config(state=tk.DISABLED)

    def _update_status_bar(self, message: str, is_error: bool = False): # Unchanged
        if hasattr(self, "status_var") and self.status_var is not None: self.status_var.set(message)

    def _handle_gdb_operation_error(self, op_name: str, err_details: Any): # Unchanged
        msg = f"Error GDB op '{op_name}': {err_details}"; logger.error(msg)
        self._update_gdb_raw_output(f"ERROR: {msg}\n", True); self._update_status_bar(f"Error: {op_name} failed.", True)
        if self.winfo_exists(): messagebox.showerror("GDB Error", msg, parent=self)

    def _start_gdb_session_action(self): # Unchanged
        if self.profile_executor_instance and self.profile_executor_instance.is_running: messagebox.showwarning("Profile Running", "Profile running. Stop first.", parent=self); return
        gdb_exe = self.app_settings.get_setting("general", "gdb_executable_path"); target_exe = self.exe_path_var.get(); gdb_script = self.app_settings.get_setting("general", "gdb_dumper_script_path")
        if not gdb_exe or not os.path.isfile(gdb_exe): messagebox.showerror("Config Error", "GDB path incorrect.", parent=self); self._check_critical_configs_and_update_gui(); return
        if not target_exe or not os.path.exists(target_exe): messagebox.showerror("Input Error", "Target exe required/not found.", parent=self); return
        dumper_opts = self.app_settings.get_category_settings("dumper_options", {})
        if self.gdb_session and self.gdb_session.is_alive(): messagebox.showwarning("Session Active", "GDB active. Stop first.", parent=self); return
        self._update_status_bar("Starting GDB..."); self._update_gdb_raw_output("Starting GDB session...\n", False); self._update_parsed_json_output(None)
        try:
            startup_timeout = self.app_settings.get_setting("timeouts", "gdb_start", 30); quit_to_no_sym = self.app_settings.get_setting("timeouts", "gdb_quit", 10)
            self.gdb_session = GDBSession(gdb_path=gdb_exe, executable_path=target_exe, gdb_script_full_path=gdb_script, dumper_options=dumper_opts)
            self.gdb_session.start(timeout=startup_timeout); self._update_gdb_raw_output(f"GDB started for '{os.path.basename(target_exe)}'.\n")
            if not self.gdb_session.symbols_found:
                self._update_gdb_raw_output("ERROR: No debug symbols. Session terminated.\n", True)
                if self.winfo_exists(): messagebox.showwarning("No Debug Symbols", f"No symbols in '{os.path.basename(target_exe)}'. Aborted.", parent=self)
                self._update_status_bar("GDB aborted: No symbols.", True);
                if self.gdb_session.is_alive(): self.gdb_session.quit(timeout=quit_to_no_sym)
                self.gdb_session = None; self._reset_gui_to_stopped_state(); self._check_critical_configs_and_update_gui(); return
            if gdb_script and os.path.isfile(gdb_script):
                if self.gdb_session.gdb_script_sourced_successfully: self._update_gdb_raw_output(f"Dumper '{os.path.basename(gdb_script)}' sourced.\n",True); self._update_status_bar(f"GDB active. Dumper '{os.path.basename(gdb_script)}' loaded."); self.gdb_dumper_status_var.set(f"Dumper: {os.path.basename(gdb_script)} (Loaded)")
                else: 
                    self._update_gdb_raw_output(f"Warn: Dumper '{os.path.basename(gdb_script)}' FAILED load.\n",True); 
                    self._update_status_bar(f"GDB active. Dumper load issue.",is_error=True); 
                    if self.winfo_exists(): messagebox.showwarning("Dumper Issue", f"Dumper '{os.path.basename(gdb_script)}' failed load.", parent=self); self.gdb_dumper_status_var.set(f"Dumper: {os.path.basename(gdb_script)} (Load Failed!)")
            elif gdb_script: self._update_gdb_raw_output(f"Warn: Dumper path '{gdb_script}' invalid.\n",True); self._update_status_bar(f"GDB active. Dumper path invalid.",is_error=True); self.gdb_dumper_status_var.set(f"Dumper: {os.path.basename(gdb_script)} (Path Invalid!)")
            else: self._update_gdb_raw_output("No dumper. JSON dump via script unavailable.\n",True); self._update_status_bar("GDB active. No dumper."); self.gdb_dumper_status_var.set("Dumper: Not Configured.")
            self.start_gdb_button.config(state=tk.DISABLED); self.set_bp_button.config(state=tk.NORMAL); self.run_button.config(state=tk.DISABLED, text="3. Run Program"); self.dump_var_button.config(state=tk.DISABLED); self.stop_gdb_button.config(state=tk.NORMAL)
            if hasattr(self, 'run_profile_button'): self.run_profile_button.config(state=tk.DISABLED) # type: ignore
            if hasattr(self, 'profile_selection_combo'): self.profile_selection_combo.config(state=tk.DISABLED) # type: ignore
            self.program_started_once = False; self.last_manual_gdb_dump_filepath = None; self._disable_save_buttons()
        except (FileNotFoundError, ConnectionError, TimeoutError) as e: self._handle_gdb_operation_error("start session", e); self.gdb_session = None; self._reset_gui_to_stopped_state(); self._check_critical_configs_and_update_gui()
        except Exception as e: logger.critical(f"MAIN CATCH start GDB: {type(e).__name__}: '{e}'", exc_info=True); self._handle_gdb_operation_error("start (unexpected)", e); self.gdb_session = None; self._reset_gui_to_stopped_state(); self._check_critical_configs_and_update_gui()

    def _set_gdb_breakpoint_action(self): # Unchanged
        if not self.gdb_session or not self.gdb_session.is_alive(): messagebox.showerror("Error", "GDB not active.", parent=self); return
        bp_loc = self.breakpoint_var.get();
        if not bp_loc: messagebox.showerror("Input Error", "BP location empty.", parent=self); return
        self._update_status_bar(f"Setting BP at '{bp_loc}'...")
        try:
            cmd_to = self.app_settings.get_setting("timeouts", "gdb_command"); output = self.gdb_session.set_breakpoint(bp_loc, timeout=cmd_to); self._update_gdb_raw_output(output, True)
            bp_disp = bp_loc[:20] + "..." if len(bp_loc) > 20 else bp_loc
            if "Breakpoint" in output and "not defined" not in output.lower() and "pending" not in output.lower(): self.set_bp_button.config(text=f"BP: {bp_disp} (Set)"); self.run_button.config(state=tk.NORMAL); self._update_status_bar(f"BP set at '{bp_loc}'.")
            elif "pending" in output.lower(): self.set_bp_button.config(text=f"BP: {bp_disp} (Pend)"); self.run_button.config(state=tk.NORMAL); self._update_status_bar(f"BP '{bp_loc}' pending."); messagebox.showinfo("BP Pending", f"BP '{bp_loc}' pending.", parent=self)
            else: self._update_status_bar(f"Issue setting BP '{bp_loc}'.", True)
        except (ConnectionError, TimeoutError) as e: self._handle_gdb_operation_error(f"set BP '{bp_loc}'", e)
        except Exception as e: self._handle_gdb_operation_error(f"set BP '{bp_loc}' (unexpected)", e)

    def _run_or_continue_gdb_action(self): # Unchanged
        if not self.gdb_session or not self.gdb_session.is_alive(): messagebox.showerror("Error", "GDB not active.", parent=self); return
        self._update_parsed_json_output(None); self._disable_save_buttons()
        try:
            output = ""; run_to = self.app_settings.get_setting("timeouts", "program_run_continue"); dumper_ok = self.gdb_session.gdb_script_sourced_successfully
            if not self.program_started_once: params = self.params_var.get(); self._update_status_bar(f"Running with params: '{params}'..."); self._update_gdb_raw_output(f"run {params}\n",True); output = self.gdb_session.run_program(params, timeout=run_to)
            else: self._update_status_bar("Continuing..."); self._update_gdb_raw_output("continue\n",True); output = self.gdb_session.continue_execution(timeout=run_to)
            self._update_gdb_raw_output(output, True); dump_btn_state = tk.NORMAL if dumper_ok else tk.DISABLED
            if "Breakpoint" in output or re.search(r"Hit Breakpoint \d+", output, re.IGNORECASE): self._update_status_bar("BP hit. Ready to dump."); self.dump_var_button.config(state=dump_btn_state); self.program_started_once = True; self.run_button.config(text="3. Continue")
            elif "Program exited normally" in output or "exited with code" in output: self._update_status_bar("Program exited."); self.dump_var_button.config(state=tk.DISABLED); self.run_button.config(text="3. Run (Restart)"); self.program_started_once = False
            elif "received signal" in output.lower() or "segmentation fault" in output.lower(): self._update_status_bar("Program signal/crash.", True); self.dump_var_button.config(state=dump_btn_state); self.program_started_once = True; self.run_button.config(text="3. Continue (Risky)")
            else: self._update_status_bar("Program running/unknown."); self.dump_var_button.config(state=dump_btn_state); self.program_started_once = True; self.run_button.config(text="3. Continue")
        except (ConnectionError, TimeoutError) as e: self._handle_gdb_operation_error("run/continue", e)
        except Exception as e: self._handle_gdb_operation_error("run/continue (unexpected)", e)

    def _dump_gdb_variable_action(self): # MODIFIED
        if not self.gdb_session or not self.gdb_session.is_alive(): messagebox.showerror("Error", "GDB session not active.", parent=self); return
        if not self.gdb_session.gdb_script_sourced_successfully: messagebox.showwarning("Dumper Script Error", "GDB dumper script not loaded. JSON dump unavailable.", parent=self); self._check_critical_configs_and_update_gui(); return
        var_expr = self.variable_var.get()
        if not var_expr: messagebox.showerror("Input Error", "Variable/Expression to dump empty.", parent=self); return
        if not self.manual_dumps_output_path: messagebox.showerror("Directory Error", "Manual dumps output directory not set.", parent=self); return

        self._update_status_bar(f"Dumping '{var_expr}' to file..."); self._update_gdb_raw_output(f"Attempting file dump of: {var_expr}\n", True)
        self.last_manual_gdb_dump_filepath = None; self._disable_save_buttons()

        timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]
        app_name_manual = sanitize_filename_component(os.path.basename(self.exe_path_var.get() if self.exe_path_var.get() else "manual_app"))
        breakpoint_manual = sanitize_filename_component(self.breakpoint_var.get() if self.breakpoint_var.get() else "manual_bp")
        variable_manual = sanitize_filename_component(var_expr)
        gdb_dump_ext_name_part = GDB_DUMP_EXTENSION.lstrip('.')

        manual_placeholders = { "{profile_name}": MANUAL_DUMP_PROFILE_NAME_PLACEHOLDER, "{app_name}": app_name_manual,
                                "{breakpoint}": breakpoint_manual, "{variable}": variable_manual,
                                "{timestamp}": timestamp_str, "{extension}": gdb_dump_ext_name_part }
        gdb_target_dump_filename = MANUAL_DUMP_FILENAME_PATTERN
        for ph, val in manual_placeholders.items(): gdb_target_dump_filename = gdb_target_dump_filename.replace(ph, val)
        if not gdb_target_dump_filename.endswith(GDB_DUMP_EXTENSION):
             base_n, _ = os.path.splitext(gdb_target_dump_filename); gdb_target_dump_filename = base_n + GDB_DUMP_EXTENSION
        gdb_target_dump_filepath = os.path.join(self.manual_dumps_output_path, gdb_target_dump_filename)

        try:
            dump_timeout = self.app_settings.get_setting("timeouts", "dump_variable")
            status_payload = self.gdb_session.dump_variable_to_json(var_expr, timeout=dump_timeout, target_output_filepath=gdb_target_dump_filepath, target_output_format="json")
            self._update_parsed_json_output(status_payload)
            if status_payload.get("status") == "success":
                filepath_written = status_payload.get("filepath_written")
                if filepath_written and os.path.exists(filepath_written):
                    self.last_manual_gdb_dump_filepath = filepath_written
                    self._update_status_bar(f"Dumped '{var_expr}' to temp: {os.path.basename(filepath_written)}.")
                    self._enable_save_buttons_if_data()
                else: self._update_status_bar(f"Dumper success, but temp file for '{var_expr}' missing.", True)
            else: error_msg = status_payload.get("details", status_payload.get("message", "Unknown dumper error")); self._update_status_bar(f"Error dumping '{var_expr}': {error_msg}", True)
        except (ConnectionError, TimeoutError) as e: self._handle_gdb_operation_error(f"dump var '{var_expr}'", e)
        except Exception as e: self._handle_gdb_operation_error(f"dump var '{var_expr}' (unexpected)", e)

    def _reset_gui_to_stopped_state(self): # Unchanged
        gdb_exe_path = self.app_settings.get_setting("general", "gdb_executable_path"); gdb_is_ok = gdb_exe_path and os.path.isfile(gdb_exe_path)
        is_prof_running = self.profile_executor_instance and self.profile_executor_instance.is_running
        if hasattr(self, "start_gdb_button"): self.start_gdb_button.config(state=tk.NORMAL if gdb_is_ok and not is_prof_running else tk.DISABLED)
        if hasattr(self, "set_bp_button"): self.set_bp_button.config(state=tk.DISABLED, text="2. Set BP")
        if hasattr(self, "run_button"): self.run_button.config(state=tk.DISABLED, text="3. Run Program")
        if hasattr(self, "dump_var_button"): self.dump_var_button.config(state=tk.DISABLED)
        if hasattr(self, "stop_gdb_button"): self.stop_gdb_button.config(state=tk.DISABLED)
        if hasattr(self, "run_profile_button") and hasattr(self, "profile_selection_combo"):
            can_run_profile = gdb_is_ok and not is_prof_running and self.profile_selection_combo.get() # type: ignore
            self.run_profile_button.config(state=tk.NORMAL if can_run_profile else tk.DISABLED); self.profile_selection_combo.config(state="readonly" if not is_prof_running else tk.DISABLED) # type: ignore
        if hasattr(self, "save_json_button"): self._disable_save_buttons()
        self.program_started_once = False; self.last_manual_gdb_dump_filepath = None
        if not is_prof_running and hasattr(self, "status_var") and self.status_var is not None: self._update_status_bar("GDB session stopped or not active.")

    def _stop_gdb_session_action(self): # Unchanged
        if self.gdb_session and self.gdb_session.is_alive():
            self._update_status_bar("Stopping GDB session...")
            try:
                kill_to = self.app_settings.get_setting("timeouts", "kill_program"); quit_to = self.app_settings.get_setting("timeouts", "gdb_quit")
                if self.program_started_once: self._update_gdb_raw_output(f"Kill output:\n{self.gdb_session.kill_program(timeout=kill_to)}\n", True)
                self.gdb_session.quit(timeout=quit_to); self._update_gdb_raw_output("GDB quit sent.\n", True)
            except Exception as e: self._handle_gdb_operation_error("stop session", e)
            finally: self.gdb_session = None; self._reset_gui_to_stopped_state(); self._load_and_populate_profiles_for_automation_tab()
        else: self._reset_gui_to_stopped_state(); self._load_and_populate_profiles_for_automation_tab()

    def _enable_save_buttons_if_data(self): # MODIFIED
        can_save = bool(self.last_manual_gdb_dump_filepath and os.path.exists(self.last_manual_gdb_dump_filepath))
        if hasattr(self, "save_json_button"): self.save_json_button.config(state=tk.NORMAL if can_save else tk.DISABLED)
        if hasattr(self, "save_csv_button"): self.save_csv_button.config(state=tk.NORMAL if can_save else tk.DISABLED)

    def _disable_save_buttons(self): # Unchanged
        if hasattr(self, "save_json_button"): self.save_json_button.config(state=tk.DISABLED)
        if hasattr(self, "save_csv_button"): self.save_csv_button.config(state=tk.DISABLED)

    def _save_dumped_data(self, final_format_type: str): # MODIFIED
        if not self.last_manual_gdb_dump_filepath or not os.path.exists(self.last_manual_gdb_dump_filepath):
            messagebox.showwarning("No Data", "No temp dump file to save from.", parent=self); return
        file_ext = f".{final_format_type.lower()}"; file_types = [(f"{final_format_type.upper()} files", f"*{file_ext}"), ("All files", "*.*")]
        var_sugg = self.variable_var.get().replace(" ", "_").replace("*","ptr").replace("->","_").replace(":","_")
        default_fname_base = f"{var_sugg}_manual_dump" if var_sugg else "gdb_manual_dump"
        try: # Suggest name based on temp file's timestamp if possible
            temp_basename = os.path.basename(self.last_manual_gdb_dump_filepath)
            match_ts = re.search(r"(\d{8}_\d{6}_\d{3})", temp_basename)
            if match_ts: default_fname_base = f"{var_sugg}_{match_ts.group(1)}"
        except Exception: pass
        final_save_filepath = filedialog.asksaveasfilename(defaultextension=file_ext, filetypes=file_types, title=f"Save Manual Dump as {final_format_type.upper()}", initialfile=f"{default_fname_base}{file_ext}", parent=self)
        if not final_save_filepath: return
        self._update_status_bar(f"Saving data as {final_format_type.upper()} to {os.path.basename(final_save_filepath)}...")
        try:
            with open(self.last_manual_gdb_dump_filepath, 'r', encoding='utf-8') as f_temp: data_from_gdb_dump = json.load(f_temp)
            if final_format_type == "json": save_to_json(data_from_gdb_dump, final_save_filepath) # Re-save for pretty print
            elif final_format_type == "csv":
                data_csv = data_from_gdb_dump
                if isinstance(data_csv, dict) and not isinstance(data_csv, list): data_csv = [data_csv]
                elif not isinstance(data_csv, list): data_csv = [{"value": data_csv}]
                elif isinstance(data_csv, list) and data_csv and not all(isinstance(i, dict) for i in data_csv): data_csv = [{"value": i} for i in data_csv]
                save_to_csv(data_csv, final_save_filepath)
            messagebox.showinfo("Save Successful", f"Data saved to:\n{final_save_filepath}", parent=self)
            self._update_status_bar(f"Data saved to {os.path.basename(final_save_filepath)}.")
            try: os.remove(self.last_manual_gdb_dump_filepath); logger.info(f"Deleted temp manual dump: {self.last_manual_gdb_dump_filepath}"); self.last_manual_gdb_dump_filepath = None; self._disable_save_buttons()
            except Exception as e_del: logger.error(f"Could not delete temp manual dump '{self.last_manual_gdb_dump_filepath}': {e_del}")
        except Exception as e: logger.error(f"Error saving manual dump: {e}", exc_info=True); messagebox.showerror("Save Error", f"Failed to save: {e}", parent=self); self._update_status_bar(f"Error saving.", True)

    def _gui_status_update(self, message: str) -> None: # Unchanged
        if hasattr(self, "profile_exec_status_var") and self.profile_exec_status_var is not None: self.profile_exec_status_var.set(message)
        logger.info(f"ProfileExec Status: {message}")

    def _gui_gdb_output_update(self, message: str) -> None: # Unchanged
        self._update_gdb_raw_output(message, append=True)

    def _gui_json_data_update(self, data: Any) -> None: # Unchanged
        self._update_parsed_json_output(data)

    def _gui_add_execution_log_entry(self, entry: ExecutionLogEntry) -> None: # Unchanged
        if self.produced_files_tree and self.winfo_exists():
            try: values = (entry.get("timestamp", ""), entry.get("breakpoint_spec", "N/A"), entry.get("variable", "N/A"), entry.get("file_produced", "N/A"), entry.get("status", "N/A"), entry.get("details", "")); item_id = self.produced_files_tree.insert("", tk.END, values=values); self.produced_files_tree.see(item_id)
            except Exception as e: logger.error(f"Failed add to tree: {e}. Entry: {entry}")

    def _clear_produced_files_tree(self) -> None: # Unchanged
        if self.produced_files_tree:
            for item in self.produced_files_tree.get_children(): self.produced_files_tree.delete(item)

    def _run_selected_profile_action(self) -> None: # Unchanged
        selected_profile_name = self.profile_selection_combo.get()
        if not selected_profile_name: messagebox.showwarning("No Profile", "Select profile.", parent=self); return
        if self.profile_executor_instance and self.profile_executor_instance.is_running: messagebox.showwarning("Profile Running", "Profile running.", parent=self); return
        if self.gdb_session and self.gdb_session.is_alive(): messagebox.showerror("GDB Active", "Manual GDB active. Stop first.", parent=self); return
        profile_data = self.available_profiles_map.get(selected_profile_name)
        if not profile_data: messagebox.showerror("Error", f"No data for profile '{selected_profile_name}'.", parent=self); return
        self.profile_exec_status_var.set(f"STARTING PROFILE '{selected_profile_name}'...")
        if self.profile_progressbar and hasattr(self.profile_exec_status_label_big, 'master'): parent_frame = self.profile_exec_status_label_big.master; self.profile_progressbar.grid(row=1, column=0, columnspan=1, sticky="ew", padx=5, pady=(2,5), in_=parent_frame); self.profile_progressbar.start(15) # type: ignore
        if hasattr(self, 'run_profile_button'): self.run_profile_button.config(state=tk.DISABLED); 
        if hasattr(self, 'stop_profile_button'): self.stop_profile_button.config(state=tk.NORMAL)
        if hasattr(self, 'profile_selection_combo'): self.profile_selection_combo.config(state=tk.DISABLED)
        try:
            if self.menubar.winfo_exists(): self.menubar.entryconfig("Profiles", state=tk.DISABLED); self.menubar.entryconfig("Options", state=tk.DISABLED)
        except tk.TclError: logger.warning("TclError disabling menubar.")
        if hasattr(self, 'start_gdb_button'): self.start_gdb_button.config(state=tk.DISABLED); 
        if hasattr(self, 'set_bp_button'): self.set_bp_button.config(state=tk.DISABLED); 
        if hasattr(self, 'run_button'): self.run_button.config(state=tk.DISABLED); 
        if hasattr(self, 'dump_var_button'): self.dump_var_button.config(state=tk.DISABLED); 
        if hasattr(self, 'stop_gdb_button'): self.stop_gdb_button.config(state=tk.DISABLED)
        self.last_run_output_path = None; 
        if hasattr(self, 'open_output_folder_button'): self.open_output_folder_button.config(state=tk.DISABLED) # type: ignore
        self.profile_executor_instance = ProfileExecutor(profile_data, self.app_settings, status_update_callback=self._gui_status_update, gdb_output_callback=self._gui_gdb_output_update, json_output_callback=self._gui_json_data_update, execution_log_callback=self._gui_add_execution_log_entry)
        self._clear_produced_files_tree(); self._update_gdb_raw_output("", False); self._update_parsed_json_output(None)
        executor_thread = threading.Thread(target=self._profile_executor_thread_target, daemon=True); executor_thread.start()

    def _profile_executor_thread_target(self): # Unchanged
        if self.profile_executor_instance:
            try: self.profile_executor_instance.run()
            finally:
                if self.winfo_exists(): self.after(0, self._on_profile_execution_finished)

    def _on_profile_execution_finished(self): # Unchanged
        if not self.winfo_exists(): logger.warning("Profile finish callback but window gone."); return
        if self.profile_progressbar: self.profile_progressbar.stop(); self.profile_progressbar.grid_remove()
        final_status_msg = "Profile execution finished."
        if self.profile_executor_instance:
            if hasattr(self.profile_executor_instance, 'current_run_output_path'): self.last_run_output_path = self.profile_executor_instance.current_run_output_path
            if self.last_run_output_path and os.path.isdir(self.last_run_output_path) and hasattr(self, 'open_output_folder_button'): self.open_output_folder_button.config(state=tk.NORMAL) # type: ignore
            else: 
                if hasattr(self, 'open_output_folder_button'): self.open_output_folder_button.config(state=tk.DISABLED) # type: ignore
                logger.warning(f"Profile output folder invalid: {self.last_run_output_path}")
            current_gui_status = self.profile_exec_status_var.get()
            if "STARTING PROFILE" in current_gui_status or "Requesting profile stop" in current_gui_status:
                if hasattr(self.profile_executor_instance, 'profile_execution_summary'):
                    exec_final_status = self.profile_executor_instance.profile_execution_summary.get("status", "Unknown")
                    if "Error" in exec_final_status or "failed" in exec_final_status.lower(): final_status_message = f"Profile finished with issues: {exec_final_status}"
                    elif exec_final_status not in ["Initialized", "Pending", "Processing Dumps"]: final_status_message = f"Profile run completed. State: {exec_final_status}"
            elif "Error:" in current_gui_status or "failed" in current_gui_status.lower(): final_status_message = f"Profile finished with issues: {current_gui_status}"
            else: final_status_message = f"Profile run completed. Last status: {current_gui_status}"
        self.profile_exec_status_var.set(final_status_message)
        if hasattr(self, 'profile_selection_combo') and self.profile_selection_combo.get(): # type: ignore
            if hasattr(self, 'run_profile_button'): self.run_profile_button.config(state=tk.NORMAL) # type: ignore
        else:
            if hasattr(self, 'run_profile_button'): self.run_profile_button.config(state=tk.DISABLED) # type: ignore
        if hasattr(self, 'stop_profile_button'): self.stop_profile_button.config(state=tk.DISABLED) # type: ignore
        if hasattr(self, 'profile_selection_combo'): self.profile_selection_combo.config(state="readonly") # type: ignore
        try:
            if self.menubar.winfo_exists(): self.menubar.entryconfig("Profiles", state=tk.NORMAL); self.menubar.entryconfig("Options", state=tk.NORMAL)
        except tk.TclError as e: logger.warning(f"TclError re-enabling menubar: {e}")
        self._check_critical_configs_and_update_gui(); self.profile_executor_instance = None; logger.info("Profile execution GUI updates completed.")

    def _stop_current_profile_action(self) -> None: # Unchanged
        if self.profile_executor_instance and self.profile_executor_instance.is_running:
            self.profile_exec_status_var.set("Requesting profile stop..."); self.profile_executor_instance.request_stop()
            if hasattr(self, 'stop_profile_button'): self.stop_profile_button.config(state=tk.DISABLED)
        else: self.profile_exec_status_var.set("No profile running to stop.")

    def _open_last_run_output_folder(self) -> None: self._open_folder_path(self.last_run_output_path, "Profile Output Folder") # Unchanged
    def _open_manual_dumps_folder(self) -> None: self._open_folder_path(self.manual_dumps_output_path, "Manual Dumps Folder") # Unchanged

    def _open_folder_path(self, folder_path: Optional[str], folder_desc: str) -> None: # Unchanged
        logger.info(f"Attempting to open {folder_desc}: '{folder_path}'")
        if not folder_path or not os.path.isdir(folder_path): messagebox.showwarning(f"No {folder_desc}", f"{folder_desc} path not set/exist.", parent=self)
        else:
            try:
                if sys.platform == "win32": os.startfile(folder_path)
                elif sys.platform == "darwin": subprocess.run(["open", folder_path], check=True)
                else: subprocess.run(["xdg-open", folder_path], check=True)
            except Exception as e: logger.error(f"Failed to open {folder_desc}: {e}", exc_info=True); messagebox.showerror("Error", f"Could not open {folder_desc.lower()}: {folder_path}\nError: {e}", parent=self)

    def _on_closing_window(self): # Unchanged
        logger.info("Window closing sequence initiated.")
        active_profile_stop_requested = False
        if self.profile_executor_instance and self.profile_executor_instance.is_running:
            response = messagebox.askyesnocancel("Profile Running", "Profile running. Stop & exit?", default=messagebox.CANCEL, parent=self)
            if response is True: self._stop_current_profile_action(); active_profile_stop_requested = True
            elif response is None: logger.info("User cancelled exit."); return
        self.app_settings.set_setting("gui", "main_window_geometry", self.geometry())
        self.app_settings.set_setting("general", "last_target_executable_path", self.exe_path_var.get())
        self.app_settings.set_setting("general", "default_breakpoint", self.breakpoint_var.get())
        self.app_settings.set_setting("general", "default_variable_to_dump", self.variable_var.get())
        self.app_settings.set_setting("general", "default_program_parameters", self.params_var.get())
        if not self.app_settings.save_settings() and self.winfo_exists(): messagebox.showwarning("Settings Error", "Could not save settings.", parent=self)
        should_destroy = True
        if self.gdb_session and self.gdb_session.is_alive():
            if self.winfo_exists() and messagebox.askokcancel("Quit GDB Session", "Manual GDB active. Stop & exit?", parent=self): self._stop_gdb_session_action()
            elif self.winfo_exists(): should_destroy = False; logger.info("User cancelled exit (manual GDB active).")
            elif not self.winfo_exists(): self._stop_gdb_session_action()
        if should_destroy:
            logger.info("Proceeding with window destruction.")
            if self.gui_log_handler: logging.getLogger().removeHandler(self.gui_log_handler); self.gui_log_handler.close(); self.gui_log_handler = None
            if active_profile_stop_requested: logger.debug("Assuming profile executor thread terminates.")
            self.destroy(); logger.info("Tkinter window destroyed.")
        else: logger.info("Window destruction aborted.")


class ScrolledTextLogHandler(logging.Handler): # Unchanged
    def __init__(self, text_widget: scrolledtext.ScrolledText): super().__init__(); self.text_widget = text_widget; self._active = True 
    def emit(self, record):
        if not self._active or not hasattr(self.text_widget, 'winfo_exists') or not self.text_widget.winfo_exists(): return
        try: log_entry = self.format(record); self.text_widget.config(state=tk.NORMAL); self.text_widget.insert(tk.END, log_entry + "\n"); self.text_widget.see(tk.END); self.text_widget.config(state=tk.DISABLED)
        except tk.TclError: self._active = False
        except Exception: self._active = False