Docker-OSX/main_app.py

# main_app.py
import sys
import subprocess
import os
import psutil
import platform
import ctypes
import json
import re
import traceback # For better error logging
import shutil # For shutil.which

from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QLabel, QComboBox, QPushButton, QTextEdit, QMessageBox, QMenuBar,
    QFileDialog, QGroupBox, QLineEdit, QProgressBar, QCheckBox
)
from PyQt6.QtGui import QAction, QIcon
from PyQt6.QtCore import pyqtSignal, pyqtSlot, QObject, QThread, QTimer, Qt

from constants import APP_NAME, DEVELOPER_NAME, BUSINESS_NAME, MACOS_VERSIONS
# DOCKER_IMAGE_BASE and Docker-related utils are no longer primary for this flow.
# utils.py might be refactored or parts removed later.

# Platform specific USB writers
USBWriterLinux = None
USBWriterMacOS = None
USBWriterWindows = None

if platform.system() == "Linux":
    try: from usb_writer_linux import USBWriterLinux
    except ImportError as e: print(f"Could not import USBWriterLinux: {e}")
elif platform.system() == "Darwin":
    try: from usb_writer_macos import USBWriterMacOS
    except ImportError as e: print(f"Could not import USBWriterMacOS: {e}")
elif platform.system() == "Windows":
    try: from usb_writer_windows import USBWriterWindows
    except ImportError as e: print(f"Could not import USBWriterWindows: {e}")

GIBMACOS_SCRIPT_PATH = os.path.join(os.path.dirname(__file__), "scripts", "gibMacOS", "gibMacOS.py")
if not os.path.exists(GIBMACOS_SCRIPT_PATH):
    GIBMACOS_SCRIPT_PATH = os.path.join(os.path.dirname(__file__), "gibMacOS.py")


class WorkerSignals(QObject):
    progress = pyqtSignal(str)
    finished = pyqtSignal(str)
    error = pyqtSignal(str)
    progress_value = pyqtSignal(int)

class GibMacOSWorker(QObject):
    signals = WorkerSignals()
    def __init__(self, version_key: str, download_path: str, catalog_key: str = "publicrelease"):
        super().__init__()
        self.version_key = version_key
        self.download_path = download_path
        self.catalog_key = catalog_key
        self.process = None
        self._is_running = True

    @pyqtSlot()
    def run(self):
        try:
            script_to_run = ""
            if os.path.exists(GIBMACOS_SCRIPT_PATH):
                script_to_run = GIBMACOS_SCRIPT_PATH
            elif shutil.which("gibMacOS.py"): # Check if it's in PATH
                 script_to_run = "gibMacOS.py"
            elif os.path.exists(os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), "gibMacOS.py")): # Check alongside main_app.py
                 script_to_run = os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), "gibMacOS.py")
            else:
                self.signals.error.emit(f"gibMacOS.py not found at expected locations or in PATH.")
                return

            version_for_gib = MACOS_VERSIONS.get(self.version_key, self.version_key)
            os.makedirs(self.download_path, exist_ok=True)

            command = [sys.executable, script_to_run, "-n", "-c", self.catalog_key, "-v", version_for_gib, "-d", self.download_path]
            self.signals.progress.emit(f"Downloading macOS '{self.version_key}' (as '{version_for_gib}') installer assets...\nCommand: {' '.join(command)}\nOutput will be in: {self.download_path}\n")

            self.process = subprocess.Popen(
                command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
                text=True, bufsize=1, universal_newlines=True,
                creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
            )

            if self.process.stdout:
                for line in iter(self.process.stdout.readline, ''):
                    if not self._is_running:
                        self.signals.progress.emit("macOS download process stopping at user request.\n")
                        break
                    line_strip = line.strip()
                    self.signals.progress.emit(line_strip)
                    progress_match = re.search(r"(\d+)%", line_strip)
                    if progress_match:
                        try: self.signals.progress_value.emit(int(progress_match.group(1)))
                        except ValueError: pass
                self.process.stdout.close()

            return_code = self.process.wait()

            if not self._is_running and return_code != 0:
                 self.signals.finished.emit(f"macOS download cancelled or stopped early (exit code {return_code}).")
                 return

            if return_code == 0:
                self.signals.finished.emit(f"macOS '{self.version_key}' installer assets downloaded to '{self.download_path}'.")
            else:
                self.signals.error.emit(f"Failed to download macOS '{self.version_key}' (gibMacOS exit code {return_code}). Check logs.")
        except FileNotFoundError:
            self.signals.error.emit(f"Error: Python or gibMacOS.py script not found. Ensure Python is in PATH and gibMacOS script is correctly located.")
        except Exception as e:
            self.signals.error.emit(f"An error occurred during macOS download: {str(e)}\n{traceback.format_exc()}")
        finally:
            self._is_running = False

    def stop(self):
        self._is_running = False
        if self.process and self.process.poll() is None:
            self.signals.progress.emit("Attempting to stop macOS download (may not be effective for active downloads)...\n")
            try:
                self.process.terminate(); self.process.wait(timeout=2)
            except subprocess.TimeoutExpired: self.process.kill()
            self.signals.progress.emit("macOS download process termination requested.\n")


class USBWriterWorker(QObject):
    signals = WorkerSignals()
    def __init__(self, device: str, macos_download_path: str,
                 enhance_plist: bool, target_macos_version: str):
        super().__init__()
        self.device = device
        self.macos_download_path = macos_download_path
        self.enhance_plist = enhance_plist
        self.target_macos_version = target_macos_version
        self.writer_instance = None

    @pyqtSlot()
    def run(self):
        current_os = platform.system()
        try:
            writer_cls = None
            if current_os == "Linux": writer_cls = USBWriterLinux
            elif current_os == "Darwin": writer_cls = USBWriterMacOS
            elif current_os == "Windows": writer_cls = USBWriterWindows

            if writer_cls is None:
                self.signals.error.emit(f"{current_os} USB writer module not available or OS not supported."); return

            # Platform writers' __init__ will need to be updated for macos_download_path
            # This assumes usb_writer_*.py __init__ signatures are now:
            # __init__(self, device, macos_download_path, progress_callback, enhance_plist_enabled, target_macos_version)
            self.writer_instance = writer_cls(
                device=self.device,
                macos_download_path=self.macos_download_path,
                progress_callback=lambda msg: self.signals.progress.emit(msg),
                enhance_plist_enabled=self.enhance_plist,
                target_macos_version=self.target_macos_version
            )

            if self.writer_instance.format_and_write():
                self.signals.finished.emit("USB writing process completed successfully.")
            else:
                self.signals.error.emit("USB writing process failed. Check output for details.")
        except Exception as e:
            self.signals.error.emit(f"USB writing preparation error: {str(e)}\n{traceback.format_exc()}")


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle(APP_NAME)
        self.setGeometry(100, 100, 800, 700) # Adjusted height

        self.active_worker_thread = None
        self.macos_download_path = None
        self.current_worker_instance = None

        self.spinner_chars = ["|", "/", "-", "\\"]; self.spinner_index = 0
        self.spinner_timer = QTimer(self); self.spinner_timer.timeout.connect(self._update_spinner_status)
        self.base_status_message = "Ready."

        self._setup_ui()
        self.status_bar = self.statusBar()
        # self.status_bar.addPermanentWidget(self.progress_bar) # Progress bar now in main layout
        self.status_bar.showMessage(self.base_status_message, 5000)
        self.refresh_usb_drives()

    def _setup_ui(self):
        menubar = self.menuBar(); file_menu = menubar.addMenu("&File"); help_menu = menubar.addMenu("&Help")
        exit_action = QAction("&Exit", self); exit_action.triggered.connect(self.close); file_menu.addAction(exit_action)
        about_action = QAction("&About", self); about_action.triggered.connect(self.show_about_dialog); help_menu.addAction(about_action)
        central_widget = QWidget(); self.setCentralWidget(central_widget); main_layout = QVBoxLayout(central_widget)

        # Step 1: Download macOS
        download_group = QGroupBox("Step 1: Download macOS Installer Assets")
        download_layout = QVBoxLayout()
        selection_layout = QHBoxLayout(); self.version_label = QLabel("Select macOS Version:"); self.version_combo = QComboBox()
        self.version_combo.addItems(MACOS_VERSIONS.keys()); selection_layout.addWidget(self.version_label); selection_layout.addWidget(self.version_combo)
        download_layout.addLayout(selection_layout)

        self.download_macos_button = QPushButton("Download macOS Installer Assets")
        self.download_macos_button.clicked.connect(self.start_macos_download_flow)
        download_layout.addWidget(self.download_macos_button)

        self.cancel_operation_button = QPushButton("Cancel Current Operation")
        self.cancel_operation_button.clicked.connect(self.stop_current_operation)
        self.cancel_operation_button.setEnabled(False)
        download_layout.addWidget(self.cancel_operation_button)
        download_group.setLayout(download_layout)
        main_layout.addWidget(download_group)

        # Step 2: USB Drive Selection & Writing
        usb_group = QGroupBox("Step 2: Create Bootable USB Installer")
        self.usb_layout = QVBoxLayout()
        self.usb_drive_label = QLabel("Available USB Drives:"); self.usb_layout.addWidget(self.usb_drive_label)
        usb_selection_layout = QHBoxLayout(); self.usb_drive_combo = QComboBox(); self.usb_drive_combo.currentIndexChanged.connect(self.update_all_button_states)
        usb_selection_layout.addWidget(self.usb_drive_combo); self.refresh_usb_button = QPushButton("Refresh List"); self.refresh_usb_button.clicked.connect(self.refresh_usb_drives)
        usb_selection_layout.addWidget(self.refresh_usb_button); self.usb_layout.addLayout(usb_selection_layout)
        self.windows_usb_guidance_label = QLabel("For Windows: Select USB disk from dropdown (WMI). Manual input below if empty/unreliable.")
        self.windows_disk_id_input = QLineEdit(); self.windows_disk_id_input.setPlaceholderText("Disk No. (e.g., 1)"); self.windows_disk_id_input.textChanged.connect(self.update_all_button_states)
        if platform.system() == "Windows": self.usb_layout.addWidget(self.windows_usb_guidance_label); self.usb_layout.addWidget(self.windows_disk_id_input); self.windows_usb_guidance_label.setVisible(True); self.windows_disk_id_input.setVisible(True)
        else: self.windows_usb_guidance_label.setVisible(False); self.windows_disk_id_input.setVisible(False)
        self.enhance_plist_checkbox = QCheckBox("Try to auto-enhance config.plist for this system's hardware (Experimental, Linux Host Only for detection)")
        self.enhance_plist_checkbox.setChecked(False); self.usb_layout.addWidget(self.enhance_plist_checkbox)
        warning_label = QLabel("WARNING: USB drive will be ERASED!"); warning_label.setStyleSheet("color: red; font-weight: bold;"); self.usb_layout.addWidget(warning_label)
        self.write_to_usb_button = QPushButton("Create macOS Installer USB"); self.write_to_usb_button.clicked.connect(self.handle_write_to_usb)
        self.write_to_usb_button.setEnabled(False); self.usb_layout.addWidget(self.write_to_usb_button); usb_group.setLayout(self.usb_layout); main_layout.addWidget(usb_group)

        self.progress_bar = QProgressBar(self); self.progress_bar.setRange(0, 0); self.progress_bar.setVisible(False); main_layout.addWidget(self.progress_bar)
        self.output_area = QTextEdit(); self.output_area.setReadOnly(True); main_layout.addWidget(self.output_area)
        self.update_all_button_states()

    def show_about_dialog(self): QMessageBox.about(self, f"About {APP_NAME}", f"Version: 1.0.0 (Installer Flow)\nDeveloper: {DEVELOPER_NAME}\nBusiness: {BUSINESS_NAME}\n\nThis tool helps create bootable macOS USB drives using gibMacOS and OpenCore.")

    def _set_ui_busy(self, busy_status: bool, message: str = "Processing..."):
        self.progress_bar.setVisible(busy_status)
        if busy_status:
            self.base_status_message = message
            if not self.spinner_timer.isActive(): self.spinner_timer.start(150)
            self._update_spinner_status()
            self.progress_bar.setRange(0,0)
        else:
            self.spinner_timer.stop()
            self.status_bar.showMessage(message or "Ready.", 7000)
        self.update_all_button_states()


    def _update_spinner_status(self):
        if self.spinner_timer.isActive():
            char = self.spinner_chars[self.spinner_index % len(self.spinner_chars)]
            active_worker_provides_progress = False
            if self.active_worker_thread and self.active_worker_thread.isRunning():
                 active_worker_provides_progress = getattr(self.active_worker_thread, "provides_progress", False)

            if active_worker_provides_progress and self.progress_bar.maximum() == 100: # Determinate
                 self.status_bar.showMessage(f"{char} {self.base_status_message} ({self.progress_bar.value()}%)")
            else:
                 if self.progress_bar.maximum() != 0: self.progress_bar.setRange(0,0)
                 self.status_bar.showMessage(f"{char} {self.base_status_message}")
            self.spinner_index = (self.spinner_index + 1) % len(self.spinner_chars)
        elif not (self.active_worker_thread and self.active_worker_thread.isRunning()):
             self.spinner_timer.stop()

    def update_all_button_states(self):
        is_worker_active = self.active_worker_thread is not None and self.active_worker_thread.isRunning()

        self.download_macos_button.setEnabled(not is_worker_active)
        self.version_combo.setEnabled(not is_worker_active)
        self.cancel_operation_button.setEnabled(is_worker_active and self.current_worker_instance is not None)

        self.refresh_usb_button.setEnabled(not is_worker_active)
        self.usb_drive_combo.setEnabled(not is_worker_active)
        if platform.system() == "Windows": self.windows_disk_id_input.setEnabled(not is_worker_active)
        self.enhance_plist_checkbox.setEnabled(not is_worker_active)

        # Write to USB button logic
        macos_assets_ready = bool(self.macos_download_path and os.path.isdir(self.macos_download_path))
        usb_identified = False
        current_os = platform.system(); writer_module = None
        if current_os == "Linux": writer_module = USBWriterLinux; usb_identified = bool(self.usb_drive_combo.currentData())
        elif current_os == "Darwin": writer_module = USBWriterMacOS; usb_identified = bool(self.usb_drive_combo.currentData())
        elif current_os == "Windows":
            writer_module = USBWriterWindows
            usb_identified = bool(self.usb_drive_combo.currentData()) or bool(self.windows_disk_id_input.text().strip())

        self.write_to_usb_button.setEnabled(not is_worker_active and macos_assets_ready and usb_identified and writer_module is not None)
        tooltip = ""
        if writer_module is None: tooltip = f"USB Writing not supported on {current_os} or module missing."
        elif not macos_assets_ready: tooltip = "Download macOS installer assets first (Step 1)."
        elif not usb_identified: tooltip = "Select or identify a target USB drive."
        else: tooltip = ""
        self.write_to_usb_button.setToolTip(tooltip)


    def _start_worker(self, worker_instance, on_finished_slot, on_error_slot, worker_name="worker", provides_progress=False):
        if self.active_worker_thread and self.active_worker_thread.isRunning():
            QMessageBox.warning(self, "Busy", "Another operation is in progress."); return False

        self._set_ui_busy(True, f"Starting {worker_name.replace('_', ' ')}...")
        self.current_worker_instance = worker_instance

        if provides_progress:
            self.progress_bar.setRange(0,100)
            worker_instance.signals.progress_value.connect(self.update_progress_bar_value)
        else:
            self.progress_bar.setRange(0,0)

        self.active_worker_thread = QThread(); self.active_worker_thread.setObjectName(worker_name + "_thread")
        setattr(self.active_worker_thread, "provides_progress", provides_progress)

        worker_instance.moveToThread(self.active_worker_thread)
        worker_instance.signals.progress.connect(self.update_output)
        worker_instance.signals.finished.connect(lambda msg, wn=worker_name, slot=on_finished_slot: self._handle_worker_finished(msg, wn, slot))
        worker_instance.signals.error.connect(lambda err, wn=worker_name, slot=on_error_slot: self._handle_worker_error(err, wn, slot))
        self.active_worker_thread.finished.connect(self.active_worker_thread.deleteLater)
        self.active_worker_thread.started.connect(worker_instance.run)
        self.active_worker_thread.start()
        return True

    @pyqtSlot(int)
    def update_progress_bar_value(self, value):
        if self.progress_bar.maximum() == 0: self.progress_bar.setRange(0,100)
        self.progress_bar.setValue(value)
        # Spinner update will happen on its timer, it can check progress_bar.value()

    def _handle_worker_finished(self, message, worker_name, specific_finished_slot):
        final_msg = f"{worker_name.replace('_', ' ').capitalize()} completed."
        self.current_worker_instance = None # Clear current worker
        self.active_worker_thread = None
        if specific_finished_slot: specific_finished_slot(message)
        self._set_ui_busy(False, final_msg)

    def _handle_worker_error(self, error_message, worker_name, specific_error_slot):
        final_msg = f"{worker_name.replace('_', ' ').capitalize()} failed."
        self.current_worker_instance = None # Clear current worker
        self.active_worker_thread = None
        if specific_error_slot: specific_error_slot(error_message)
        self._set_ui_busy(False, final_msg)

    def start_macos_download_flow(self):
        self.output_area.clear(); selected_version_name = self.version_combo.currentText()
        gibmacos_version_arg = MACOS_VERSIONS.get(selected_version_name, selected_version_name)

        chosen_path = QFileDialog.getExistingDirectory(self, "Select Directory to Download macOS Installer Assets")
        if not chosen_path: self.output_area.append("Download directory selection cancelled."); return
        self.macos_download_path = chosen_path

        worker = GibMacOSWorker(gibmacos_version_arg, self.macos_download_path)
        if not self._start_worker(worker, self.macos_download_finished, self.macos_download_error,
                                  "macos_download",
                                  f"Downloading macOS {selected_version_name} assets...",
                                  provides_progress=True): # Assuming GibMacOSWorker will emit progress_value
            self._set_ui_busy(False, "Failed to start macOS download operation.")


    @pyqtSlot(str)
    def macos_download_finished(self, message):
        QMessageBox.information(self, "Download Complete", message)
        # self.macos_download_path is set. UI update handled by generic handler.

    @pyqtSlot(str)
    def macos_download_error(self, error_message):
        QMessageBox.critical(self, "Download Error", error_message)
        self.macos_download_path = None
        # UI reset by generic handler.

    def stop_current_operation(self):
        if self.current_worker_instance and hasattr(self.current_worker_instance, 'stop'):
            self.output_area.append(f"
--- Attempting to stop {self.active_worker_thread.objectName().replace('_thread','')} ---")
            self.current_worker_instance.stop()
        else:
            self.output_area.append("
--- No active stoppable operation or stop method not implemented for current worker. ---")

    def handle_error(self, message):
        self.output_area.append(f"ERROR: {message}"); QMessageBox.critical(self, "Error", message)
        self._set_ui_busy(False, "Error occurred.")

    def check_admin_privileges(self) -> bool: # ... (same)
        try:
            if platform.system() == "Windows": return ctypes.windll.shell32.IsUserAnAdmin() != 0
            else: return os.geteuid() == 0
        except Exception as e: self.output_area.append(f"Could not check admin privileges: {e}"); return False

    def refresh_usb_drives(self): # ... (same logic as before)
        self.usb_drive_combo.clear(); current_selection_text = getattr(self, '_current_usb_selection_text', None)
        self.output_area.append("
Scanning for disk devices...")
        if platform.system() == "Windows":
            self.usb_drive_label.setText("Available USB Disks (Windows - via WMI/PowerShell):")
            self.windows_usb_guidance_label.setVisible(True); self.windows_disk_id_input.setVisible(False);
            powershell_command = "Get-WmiObject Win32_DiskDrive | Where-Object {$_.InterfaceType -eq 'USB'} | Select-Object DeviceID, Index, Model, @{Name='SizeGB';Expression={[math]::Round($_.Size / 1GB, 2)}} | ConvertTo-Json"
            try:
                process = subprocess.run(["powershell", "-Command", powershell_command], capture_output=True, text=True, check=True, creationflags=subprocess.CREATE_NO_WINDOW)
                disks_data = json.loads(process.stdout); disks_json = disks_data if isinstance(disks_data, list) else [disks_data] if disks_data else []
                if disks_json:
                    for disk in disks_json:
                        if disk.get('DeviceID') is None or disk.get('Index') is None: continue
                        disk_text = f"Disk {disk['Index']}: {disk.get('Model','N/A')} ({disk.get('SizeGB','N/A')} GB) - {disk['DeviceID']}"
                        self.usb_drive_combo.addItem(disk_text, userData=str(disk['Index']))
                    self.output_area.append(f"Found {len(disks_json)} USB disk(s) via WMI.");
                    if current_selection_text:
                        for i in range(self.usb_drive_combo.count()):
                            if self.usb_drive_combo.itemText(i) == current_selection_text: self.usb_drive_combo.setCurrentIndex(i); break
                else: self.output_area.append("No USB disks found via WMI/PowerShell. Manual input field shown as fallback."); self.windows_disk_id_input.setVisible(True)
            except Exception as e: self.output_area.append(f"Error scanning Windows USBs with PowerShell: {e}"); self.windows_disk_id_input.setVisible(True)
        else:
            self.usb_drive_label.setText("Available USB Drives (for Linux/macOS):")
            self.windows_usb_guidance_label.setVisible(False); self.windows_disk_id_input.setVisible(False)
            try:
                partitions = psutil.disk_partitions(all=False); potential_usbs = []
                for p in partitions:
                    is_removable = 'removable' in p.opts; is_likely_usb = False
                    if platform.system() == "Darwin" and p.device.startswith("/dev/disk") and 'external' in p.opts.lower() and 'physical' in p.opts.lower(): is_likely_usb = True
                    elif platform.system() == "Linux" and ((p.mountpoint and ("/media/" in p.mountpoint or "/run/media/" in p.mountpoint)) or                        (p.device.startswith("/dev/sd") and not p.device.endswith("da"))): is_likely_usb = True
                    if is_removable or is_likely_usb:
                        try: usage = psutil.disk_usage(p.mountpoint); size_gb = usage.total / (1024**3)
                        except Exception: continue
                        if size_gb < 0.1 : continue
                        drive_text = f"{p.device} @ {p.mountpoint} ({p.fstype}, {size_gb:.2f} GB)"
                        potential_usbs.append((drive_text, p.device))
                if potential_usbs:
                    idx_to_select = -1
                    for i, (text, device_path) in enumerate(potential_usbs): self.usb_drive_combo.addItem(text, userData=device_path);
                    if text == current_selection_text: idx_to_select = i
                    if idx_to_select != -1: self.usb_drive_combo.setCurrentIndex(idx_to_select)
                    self.output_area.append(f"Found {len(potential_usbs)} potential USB drive(s). Please verify carefully.")
                else: self.output_area.append("No suitable USB drives found for Linux/macOS.")
            except ImportError: self.output_area.append("psutil library not found.")
            except Exception as e: self.output_area.append(f"Error scanning for USB drives: {e}")
        self.update_all_button_states()


    def handle_write_to_usb(self):
        if not self.check_admin_privileges(): QMessageBox.warning(self, "Privileges Required", "This operation requires Administrator/root privileges."); return
        if not self.macos_download_path or not os.path.isdir(self.macos_download_path): QMessageBox.warning(self, "Missing macOS Assets", "Download macOS installer assets first."); return
        current_os = platform.system(); usb_writer_module = None; target_device_id_for_worker = None
        if current_os == "Windows": target_device_id_for_worker = self.usb_drive_combo.currentData() or self.windows_disk_id_input.text().strip(); usb_writer_module = USBWriterWindows
        else: target_device_id_for_worker = self.usb_drive_combo.currentData(); usb_writer_module = USBWriterLinux if current_os == "Linux" else USBWriterMacOS if current_os == "Darwin" else None
        if not usb_writer_module: QMessageBox.warning(self, "Unsupported Platform", f"USB writing not supported for {current_os}."); return
        if not target_device_id_for_worker: QMessageBox.warning(self, "No USB Selected/Identified", f"Please select/identify target USB."); return
        if current_os == "Windows" and target_device_id_for_worker.isdigit(): target_device_id_for_worker = f"disk {target_device_id_for_worker}"

        enhance_plist_state = self.enhance_plist_checkbox.isChecked()
        target_macos_name = self.version_combo.currentText()
        reply = QMessageBox.warning(self, "Confirm Write Operation", f"WARNING: ALL DATA ON TARGET '{target_device_id_for_worker}' WILL BE ERASED.
Proceed?", QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Cancel, QMessageBox.StandardButton.Cancel)
        if reply == QMessageBox.StandardButton.Cancel: self.output_area.append("
USB write cancelled."); return

        # USBWriterWorker now needs different args
        # The platform specific writers (USBWriterLinux etc) will need to be updated to accept macos_download_path
        # and use it to find BaseSystem.dmg, EFI/OC etc. instead of opencore_qcow2_path, macos_qcow2_path
        usb_worker_adapted = USBWriterWorker(
            device=target_device_id_for_worker,
            macos_download_path=self.macos_download_path,
            enhance_plist=enhance_plist_state,
            target_macos_version=target_macos_name
        )

        if not self._start_worker(usb_worker_adapted, self.usb_write_finished, self.usb_write_error, "usb_write_worker",
                                  busy_message=f"Creating USB for {target_device_id_for_worker}...",
                                  provides_progress=False): # USB writing can be long, but progress parsing is per-platform script.
            self._set_ui_busy(False, "Failed to start USB write operation.")

    @pyqtSlot(str)
    def usb_write_finished(self, message): QMessageBox.information(self, "USB Write Complete", message)
    @pyqtSlot(str)
    def usb_write_error(self, error_message): QMessageBox.critical(self, "USB Write Error", error_message)

    def closeEvent(self, event): # ... (same logic)
        self._current_usb_selection_text = self.usb_drive_combo.currentText()
        if self.active_worker_thread and self.active_worker_thread.isRunning():
            reply = QMessageBox.question(self, 'Confirm Exit', "An operation is running. Exit anyway?", QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, QMessageBox.StandardButton.No)
            if reply == QMessageBox.StandardButton.Yes:
                if self.current_worker_instance and hasattr(self.current_worker_instance, 'stop'): self.current_worker_instance.stop()
                else: self.active_worker_thread.quit()
                self.active_worker_thread.wait(1000); event.accept()
            else: event.ignore(); return
        else: event.accept()


if __name__ == "__main__":
    import traceback # Ensure traceback is available for GibMacOSWorker
    import shutil # Ensure shutil is available for GibMacOSWorker path check
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())