# Original approach - threading wrapper around blocking subprocess
class HighToGameReadyTool(QMainWindow):
    def __init__(self):
        super().__init__()
        self.threadpool = QThreadPool()  # Thread pool for "async" execution

    def _houdini_process_task(self):
        """Wrapper to run Houdini in thread"""
        if BP_PY_TOOL_RUN_THREADED:
            # Create worker thread
            worker = Worker(self._run_houdini_subprocess)
            worker.signals.interrupt.connect(self.handle_worker_error)
            worker.signals.finished.connect(self.houdini_finished.emit)
            self.threadpool.start(worker)  # Run in background thread
        else:
            self._run_houdini_subprocess()  # Direct blocking call

    def _run_houdini_subprocess(self):
        """The actual subprocess execution - THIS BLOCKS ANYWAY"""
        process = subprocess.Popen(
            [houdini_exe, script_path, *args],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE
        )

        # Read output line by line - BLOCKING I/O
        for line in iter(process.stdout.readline, b''):
            decoded = line.decode('utf-8').strip()
            _LOGGER.info(f"[Houdini] {decoded}")

        # Wait for completion - BLOCKING WAIT
        process.wait()
        return process.returncode

# Multiple independent API calls that CAN run simultaneously
from concurrent.futures import ThreadPoolExecutor

def fetch_asset_metadata(asset_id):
    """Each call is independent, takes 1 second"""
    response = requests.get(f"https://api.example.com/assets/{asset_id}")
    return response.json()

def fetch_all_assets_parallel(asset_ids):
    """Fetch 10 assets in ~1 second instead of ~10 seconds"""
    with ThreadPoolExecutor(max_workers=10) as executor:
        futures = [executor.submit(fetch_asset_metadata, id) for id in asset_ids]
        results = [f.result() for f in futures]
    return results

# Performance improvement: 10x faster (10 seconds → 1 second)
# Why it works: Each API call is I/O bound and independent
# While waiting for network responses, threads can make other calls

# Sequential pipeline where each step DEPENDS on the previous
def process_assets_sequential():
    # Step 1: Must complete first
    high_files = gather_high_poly_files()

    # Step 2: CANNOT start until Step 1 produces output files
    houdini_result = run_houdini_subprocess(high_files)  # BLOCKS for 2-5 min
    low_files = houdini_result.output_files

    # Step 3: CANNOT start until Step 2 produces output files
    substance_result = run_substance_subprocess(low_files)  # BLOCKS for 1-3 min
    texture_files = substance_result.output_files

    # Step 4: CANNOT start until Step 3 produces output files
    maya_result = run_maya_subprocess(texture_files)  # BLOCKS for 1-2 min

    return maya_result

# Adding threads here provides ZERO benefit because:
# - Each step blocks waiting for external process
# - Each step MUST complete before next can begin
# - No parallel work exists
# - External processes (Houdini/Substance/Maya) do the actual work

# Separate progress window with threading complexity
class HighToGameReadyTool(QMainWindow):
    def process_all(self):
        # Show separate progress dialog
        self.progress_bar = BP_Progress_Bar(parent=self)
        self.progress_bar.show()

        # Wrap in thread
        worker = Worker(self._process_pipeline)
        worker.signals.progress.connect(self.progress_bar.update)
        worker.signals.finished.connect(self.progress_bar.close)
        self.threadpool.start(worker)

        # User still can't interact with main UI during processing
        # Progress bar just shows status
        # What did threading accomplish? Nothing.

# Modal progress dialog - simple and honest about blocking
def process_all(self):
    progress = QProgressDialog("Processing...", "Cancel", 0, 100, self)
    progress.setWindowModality(Qt.WindowModal)
    progress.show()

    # Process directly, update progress
    progress.setValue(10)
    self._process_houdini()

    progress.setValue(40)
    self._process_substance()

    progress.setValue(70)
    self._process_maya()

    progress.setValue(100)

    # Advantages:
    # - No threading complexity
    # - Honest about blocking (modal dialog)
    # - User knows they're waiting
    # - No race conditions
    # - 100 fewer lines of code

# Multiple independent I/O operations that can overlap
import asyncio

async def fetch_from_api(url):
    """Single API call using async HTTP client"""
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.json()

async def fetch_multiple_resources():
    """Fetch multiple resources concurrently"""
    results = await asyncio.gather(
        fetch_from_api("https://api1.example.com/data"),  # Waiting for network
        fetch_from_api("https://api2.example.com/data"),  # Waiting for network
        fetch_from_api("https://api3.example.com/data"),  # Waiting for network
    )
    return results

# All three fetch simultaneously while waiting for I/O
# Single-threaded event loop manages concurrency
# Performance: 3x faster than sequential

# Sequential dependencies - async adds nothing
async def process_pipeline():
    # Step 1: Must complete first
    high_files = await gather_high_files()  # Async file scanning

    # Step 2: MUST wait for Step 1 to complete
    low_files = await run_houdini(high_files)  # Subprocess blocks

    # Step 3: MUST wait for Step 2 to complete
    textures = await run_substance(low_files)  # Subprocess blocks

    # Step 4: MUST wait for Step 3 to complete
    result = await run_maya(textures)  # Subprocess blocks

    return result

# Problems:
# - No parallelism (each await blocks the next step)
# - Added async/await keywords everywhere (complexity)
# - subprocess.Popen() isn't even async-compatible
# - Would need asyncio.create_subprocess_exec()
# - Result: More code, same performance

# Thread wrapper around blocking subprocess
class ToolWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.threadpool = QThreadPool()

    def run_houdini_threaded(self):
        """Start Houdini in background thread"""
        worker = Worker(self._run_houdini_subprocess)
        worker.signals.finished.connect(self.on_houdini_finished)
        self.threadpool.start(worker)

    def _run_houdini_subprocess(self):
        """Runs in worker thread - but still blocks that thread"""
        process = subprocess.Popen(
            [houdini_exe, script_path],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE
        )

        # Thread BLOCKS here reading output
        for line in iter(process.stdout.readline, b''):
            decoded = line.decode('utf-8').strip()
            # Cross-thread signal emission
            self.log_signal.emit(f"[Houdini] {decoded}")

        # Thread BLOCKS here waiting for completion
        process.wait()
        return process.returncode

# Problems:
# - Worker thread still blocks (no parallel work achieved)
# - Signal marshalling across thread boundary
# - Thread-safety concerns for shared state
# - ~50 lines of boilerplate (Worker class, signals, thread pool)
# - No real-time output (buffering in thread)

# Qt-native async subprocess
class ToolWindow(QMainWindow):
    # Signals for pipeline orchestration
    houdini_finished = Signal()
    substance_finished = Signal()
    maya_finished = Signal()

    def __init__(self):
        super().__init__()
        self._houdini_process = None

        # Connect pipeline: each stage triggers the next
        self.houdini_finished.connect(self.houdini_post)
        self.substance_finished.connect(self.substance_post)
        self.maya_finished.connect(self.maya_post)

    def _start_houdini_qprocess(self):
        """Start Houdini using QProcess - returns immediately"""
        self._houdini_process = QProcess(self)

        # Connect signals (Qt event loop handles everything)
        self._houdini_process.readyReadStandardOutput.connect(
            self._on_houdini_stdout
        )
        self._houdini_process.readyReadStandardError.connect(
            self._on_houdini_stderr
        )
        self._houdini_process.finished.connect(
            self._on_houdini_finished
        )
        self._houdini_process.errorOccurred.connect(
            self._on_houdini_error
        )

        # Set environment for subprocess isolation
        env_dict = load_json_environment(BP_HOUDINI_ENV_JSON)
        env_list = [f"{k}={v}" for k, v in env_dict.items()]
        self._houdini_process.setEnvironment(env_list)

        # Start process - RETURNS IMMEDIATELY, doesn't block
        self._houdini_process.start(hython_exe, [script_path, *args])

        self.logger.info(f"Started Houdini subprocess (PID: {self._houdini_process.processId()})")

    @Slot()
    def _on_houdini_stdout(self):
        """Called automatically when stdout has data - NO BLOCKING"""
        data = self._houdini_process.readAllStandardOutput().data().decode('utf-8')
        for line in data.splitlines():
            if line.strip():
                self.logger.info(f"[Houdini] {line}")
                # Update UI console in real-time
                self.console_widget.append(f"[Houdini] {line}")

    @Slot()
    def _on_houdini_stderr(self):
        """Called automatically when stderr has data"""
        data = self._houdini_process.readAllStandardError().data().decode('utf-8')
        for line in data.splitlines():
            if line.strip():
                self.logger.warning(f"[Houdini ERROR] {line}")

    @Slot(int, QProcess.ExitStatus)
    def _on_houdini_finished(self, exit_code, exit_status):
        """Called automatically when process completes"""
        if exit_code == 0 and exit_status == QProcess.NormalExit:
            self.logger.info("✓ Houdini completed successfully")
            self.houdini_finished.emit()  # Trigger next stage
        else:
            self.logger.error(f"✗ Houdini failed with code {exit_code}")
            self._handle_houdini_error(exit_code)

    @Slot(QProcess.ProcessError)
    def _on_houdini_error(self, error):
        """Called if process fails to start or crashes"""
        error_strings = {
            QProcess.FailedToStart: "Failed to start",
            QProcess.Crashed: "Process crashed",
            QProcess.Timedout: "Process timed out",
            QProcess.WriteError: "Write error",
            QProcess.ReadError: "Read error",
            QProcess.UnknownError: "Unknown error"
        }
        self.logger.error(f"Houdini process error: {error_strings.get(error, 'Unknown')}")

# Advantages:
# - No threading complexity
# - No signal marshalling across threads
# - Real-time output (Qt event loop delivers instantly)
# - Qt handles all concurrency (no race conditions)
# - UI remains responsive (event loop keeps processing events)
# - Clean, readable code
# - ~30 lines (vs 50+ for threading approach)

def houdini_post(self):
    """Called when Houdini completes - post-process and start next stage"""
    self.logger.info("Post-processing Houdini outputs...")

    # Validate output files exist
    if self._validate_houdini_outputs():
        # Start next stage
        self._start_substance_qprocess()
    else:
        self.logger.error("Houdini outputs failed validation")
        self._handle_pipeline_error()

def substance_post(self):
    """Called when Substance completes - post-process and start next stage"""
    self.logger.info("Post-processing Substance outputs...")

    # Validate textures
    if self._validate_substance_outputs():
        # Start final stage
        self._start_maya_qprocess()
    else:
        self.logger.error("Substance outputs failed validation")
        self._handle_pipeline_error()

def maya_post(self):
    """Called when Maya completes - finalize pipeline"""
    self.logger.info("Post-processing Maya outputs...")

    # Final validation and cleanup
    if self._validate_maya_outputs():
        self._finalize_successful_pipeline()
    else:
        self._handle_pipeline_error()

# Threading adds zero value here
def process_assets(self):
    worker = Worker(self._run_all_steps)
    self.threadpool.start(worker)

def _run_all_steps(self):
    self._run_houdini()    # BLOCKS waiting for Houdini
    self._run_substance()  # BLOCKS waiting for Substance  
    self._run_maya()       # BLOCKS waiting for Maya
    # Thread just waits - provides nothing

# Direct execution - simple but blocks UI completely
def process_assets(self):
    progress = QProgressDialog("Processing...", "Cancel", 0, 3, self)
    progress.setWindowModality(Qt.WindowModal)
    
    progress.setValue(0)
    subprocess.run([houdini_exe, args])  # UI freezes here for 2-5 min
    
    progress.setValue(1)
    subprocess.run([substance_exe, args])  # UI freezes here for 1-3 min
    
    progress.setValue(2) 
    subprocess.run([maya_exe, args])  # UI freezes here for 1-2 min
    
    progress.setValue(3)

# Non-blocking subprocess with real-time output
def process_assets(self):
    self.progressbar.setMaximum(0)  # Indeterminate
    self._start_houdini_qprocess()  # Returns immediately

def _start_houdini_qprocess(self):
    self._houdini_process = QProcess(self)
    self._houdini_process.finished.connect(self._on_houdini_finished)
    self._houdini_process.start(program, args)  # Non-blocking

@Slot(int, QProcess.ExitStatus)
def _on_houdini_finished(self, exit_code, exit_status):
    if exit_code == 0:
        self._start_substance_qprocess()  # Chain to next
    else:
        self.logger.error("Houdini failed")

# UI responsive, real-time logging, proper error handling

# Slow - each file takes 2 seconds = 200 seconds total
for texture in textures:
    process_texture(texture)  # resize, compress, generate mipmaps

# Fast - 100 files in ~25 seconds with 8 workers
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
from PIL import Image

def process_texture(texture_path):
    """Resize, compress, generate mipmaps - takes ~2 seconds per file"""
    img = Image.open(texture_path)
    
    # Resize to power-of-two dimensions
    img_resized = img.resize((2048, 2048), Image.Resampling.LANCZOS)
    
    # Save compressed
    output = texture_path.parent / f"{texture_path.stem}_compressed.jpg"
    img_resized.save(output, quality=85, optimize=True)
    
    return output

def process_textures_parallel(texture_dir):
    textures = list(Path(texture_dir).glob("*.png"))
    
    with ThreadPoolExecutor(max_workers=8) as executor:
        futures = {executor.submit(process_texture, t): t for t in textures}
        
        results = []
        for future in as_completed(futures):
            texture = futures[future]
            try:
                result = future.result()
                print(f"✓ Completed: {texture.name}")
                results.append(result)
            except Exception as e:
                print(f"✗ Failed: {texture.name} - {e}")
        
        return results

# Performance: 8x faster (87% speedup)
# Sequential: 200 seconds (100 files × 2 sec each)
# Parallel (8 workers): 25 seconds (files overlap during I/O waits)
# Why it works: Files are INDEPENDENT, I/O bound (disk reads/writes), can overlap

# Over-engineered for the use case
class ImportWorker(QRunnable):
    def run(self):
        for chunk in file_chunks:
            process_chunk(chunk)
            self.signals.progress.emit(percent)  # Cross-thread signal

# Proper Qt threading pattern
class ImportThread(QThread):
    progress = Signal(int)
    
    def run(self):
        for i, chunk in enumerate(file_chunks):
            process_chunk(chunk)
            self.progress.emit(int(100 * i / len(file_chunks)))

# In main window
thread = ImportThread()
thread.progress.connect(self.progress_bar.setValue)
thread.start()

# Simpler and often sufficient
def import_file(self, file_path):
    progress = QProgressDialog(...)
    chunks = load_file_chunks(file_path)
    
    for i, chunk in enumerate(chunks):
        process_chunk(chunk)
        progress.setValue(int(100 * i / len(chunks)))
        QApplication.processEvents()  # Keep UI responsive
        
        if progress.wasCanceled():
            break

# No threading, no complexity, works great for <10 second operations

# BAD: Each step depends on previous - why thread?
worker1 = Worker(step1)
worker1.finished.connect(lambda: worker2.start())
worker2.finished.connect(lambda: worker3.start())

# BAD: If only one thing runs at a time, why pool?
self.threadpool.setMaxThreadCount(1)
self.threadpool.start(worker)

# BAD: Thread just waits for process - provides nothing
def run_in_thread():
    process = subprocess.Popen(...)
    process.wait()  # Thread blocks here
    return process.returncode

# BAD: If always False, delete the threading code
if BP_PY_TOOL_RUN_THREADED:  # Always False in production
    run_in_thread()
else:
    run_directly()

# BAD: Thread-unsafe global access
def worker_function():
    global _P4_WORKING_CHANGELIST_NUMBER
    _P4_WORKING_CHANGELIST_NUMBER = create_changelist()
    # Race condition if multiple workers run

import time
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from PIL import Image

def compress_texture(texture_path):
    """Compress one texture file"""
    img = Image.open(texture_path)
    output = texture_path.with_suffix('.jpg')
    img.save(output, quality=85, optimize=True)
    return output

# Get realistic test data (using 100 files for testing - adjust for your use case)
textures = list(Path("test_textures").glob("*.png"))[:100]

# Benchmark 1: Sequential processing
print("Testing sequential...")
start = time.perf_counter()
for texture in textures:
    compress_texture(texture)
sequential_time = time.perf_counter() - start
print(f"Sequential: {sequential_time:.2f}s")

# Benchmark 2: Parallel processing
print("\nTesting parallel (8 workers)...")
start = time.perf_counter()
with ThreadPoolExecutor(max_workers=8) as executor:
    list(executor.map(compress_texture, textures))
parallel_time = time.perf_counter() - start
print(f"Parallel: {parallel_time:.2f}s")

# Calculate actual speedup
speedup = sequential_time / parallel_time
overhead = (sequential_time - parallel_time) / sequential_time * 100

print(f"\nSpeedup: {speedup:.2f}x ({overhead:.1f}% faster)")
print(f"Time saved: {sequential_time - parallel_time:.1f} seconds")

# Example output:
# Sequential: 184.3s
# Parallel: 23.1s
# Speedup: 7.98x (87.5% faster)
# Time saved: 161.2 seconds

# Decision guidelines:
# - Speedup > 2x: Threading is definitely worth it
# - Speedup 1.5-2x: Probably worth it (depends on complexity)
# - Speedup < 1.5x: Threading overhead not justified
# - Speedup < 1.1x: Threading provides no real benefit

# high_to_game_ready/tool.py - BEFORE (threading)

class BP_HighToGameReadyTool(QMainWindow):
    def __init__(self):
        super().__init__()
        self.threadpool = QThreadPool()
        self.progress_bar = None

    def processAssets(self):
        """Main entry point - user clicks 'Run' button"""
        # Create separate progress window
        self.progress_bar = BP_Progress_Bar(parent=self)
        self.progress_bar.show()

        # Start Houdini in thread
        self._houdini_process_task()

    def _houdini_process_task(self):
        """Wrapper to run Houdini in background thread"""
        if BP_PY_TOOL_RUN_THREADED:  # Global flag
            # Create worker
            worker = Worker(self._run_houdini_subprocess)

            # Connect signals
            worker.signals.interrupt.connect(self.handle_worker_error)
            worker.signals.finished.connect(self._on_houdini_thread_finished)
            worker.signals.progress.connect(self.progress_bar.update)

            # Start thread
            self.threadpool.start(worker)
        else:
            # Direct blocking call (debugging mode)
            self._run_houdini_subprocess()
            self._on_houdini_thread_finished()

    def _run_houdini_subprocess(self):
        """Blocking subprocess call - runs in worker thread"""
        # Build command
        hython_exe = BP_HYTHON
        script_path = BP_COOK_TOPS_NETWORK_PY
        hip_file = BP_ROCK_BATCH_HIP

        cmd = [
            str(hython_exe),
            str(script_path),
            str(hip_file),
            "topnet1",  # Network to cook
            "--verbosity", "2"
        ]

        _LOGGER.info(f"Starting Houdini: {' '.join(cmd)}")

        # Start subprocess - THIS BLOCKS THE THREAD
        process = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            universal_newlines=True
        )

        # Read output - THIS BLOCKS THE THREAD
        for line in iter(process.stdout.readline, ''):
            if line.strip():
                _LOGGER.info(f"[Houdini] {line.strip()}")
                # Cross-thread signal to update UI
                self.log_signal.emit(f"[Houdini] {line.strip()}")

        # Wait for completion - THIS BLOCKS THE THREAD
        process.wait()

        _LOGGER.info(f"Houdini finished with code: {process.returncode}")
        return process.returncode

    def _on_houdini_thread_finished(self):
        """Called when thread completes - back on main thread"""
        _LOGGER.info("Houdini thread finished, starting post-processing")

        # Post-process (validate outputs, etc.)
        self._houdini_post_process()

        # Start next stage in new thread
        self._substance_process_task()

    def handle_worker_error(self, error):
        """Error handler for thread failures"""
        _LOGGER.error(f"Worker thread error: {error}")
        if self.progress_bar:
            self.progress_bar.close()

# Problems with this approach:
# 1. Thread blocks anyway (process.wait())
# 2. Cross-thread signal marshalling
# 3. Separate progress window
# 4. Thread-safety concerns
# 5. Complex state management
# 6. No real-time output (buffered across threads)

# high_to_game_ready/tool.py - AFTER (QProcess)

class BP_HighToGameReadyTool(BP_BaseToolWindow):
    # Define signals for pipeline orchestration
    houdini_finished = Signal()
    substance_finished = Signal()
    maya_finished = Signal()

    def __init__(self):
        super().__init__()

        # QProcess instances (will be created on demand)
        self._houdini_process = None
        self._substance_process = None
        self._maya_process = None

        # Connect pipeline orchestration
        self.houdini_finished.connect(self.houdini_post)
        self.substance_finished.connect(self.substance_post)
        self.maya_finished.connect(self.maya_post)

        # Embedded console widget (part of main window)
        self.console_widget = self.findChild(QTextEdit, "consoleOutput")

    def processAssets(self):
        """Main entry point - user clicks 'Run' button"""
        self.logger.info("Starting asset processing pipeline...")

        # Reset retry counters for this run
        self._houdini_retry_count_this_run = 0
        self._substance_retry_count_this_run = 0
        self._maya_retry_count_this_run = 0
        self._pipeline_cancelled = False

        # Disable UI controls during processing
        self._set_controls_enabled(False)

        # Start first stage (returns immediately)
        self._start_houdini_qprocess()

    def _start_houdini_qprocess(self):
        """Start Houdini subprocess using QProcess - non-blocking"""
        self._houdini_process = QProcess(self)

        # Connect QProcess signals to our handlers
        self._houdini_process.readyReadStandardOutput.connect(
            self._on_houdini_stdout
        )
        self._houdini_process.readyReadStandardError.connect(
            self._on_houdini_stderr
        )
        self._houdini_process.finished.connect(
            self._on_houdini_finished
        )
        self._houdini_process.errorOccurred.connect(
            self._on_houdini_error
        )

        # Load Houdini environment from JSON (subprocess isolation)
        # Why JSON environments? Each DCC ships conflicting Python versions:
        #   - Houdini 20.0: Python 3.10.10
        #   - Substance Designer: Python 3.9.7
        #   - Maya 2024: Python 3.11.4
        # Subprocess isolation prevents package conflicts and ensures each DCC
        # gets exactly the PATH, PYTHONPATH, and environment it needs.
        env_dict = load_json_environment(BP_HOUDINI_ENV_JSON)

        # Add tool paths
        pythonpath = env_dict.get("PYTHONPATH", "")
        tool_paths = str(BP_PY_TOOL_PACKAGES)
        env_dict["PYTHONPATH"] = f"{pythonpath};{tool_paths}" if pythonpath else tool_paths

        # Convert to QProcess format
        env_list = [f"{k}={v}" for k, v in env_dict.items()]
        self._houdini_process.setEnvironment(env_list)

        # Build command
        hython_exe = str(BP_HYTHON)
        script_path = str(BP_COOK_TOPS_NETWORK_PY)
        hip_file = str(BP_ROCK_BATCH_HIP)

        args = [
            script_path,
            hip_file,
            "topnet1",
            "--verbosity", "2"
        ]

        # Start process - RETURNS IMMEDIATELY (non-blocking)
        self._houdini_process.start(hython_exe, args)

        pid = self._houdini_process.processId()
        self.logger.info(f"Started Houdini subprocess (PID: {pid})")
        self.console_widget.append(f"▶ Starting Houdini (PID: {pid})...")

    @Slot()
    def _on_houdini_stdout(self):
        """
        Called by Qt event loop when Houdini writes to stdout.
        Runs on main thread, no signal marshalling needed.
        """
        # Read available data
        data = self._houdini_process.readAllStandardOutput().data().decode('utf-8')

        # Process line by line
        for line in data.splitlines():
            if line.strip():
                # Log to file
                self.logger.info(f"[Houdini] {line}")

                # Update console widget (real-time)
                self.console_widget.append(f"[Houdini] {line}")

    @Slot()
    def _on_houdini_stderr(self):
        """Called when Houdini writes to stderr"""
        data = self._houdini_process.readAllStandardError().data().decode('utf-8')

        for line in data.splitlines():
            if line.strip():
                self.logger.warning(f"[Houdini ERROR] {line}")
                self.console_widget.append(f"<span style='color:red'>[Houdini ERROR] {line}</span>")

    @Slot(int, QProcess.ExitStatus)
    def _on_houdini_finished(self, exit_code, exit_status):
        """
        Called by Qt event loop when Houdini process completes.
        Emits signal to trigger next stage.
        """
        if exit_code == 0 and exit_status == QProcess.NormalExit:
            self.logger.info("✓ Houdini completed successfully")
            self.console_widget.append("✓ Houdini completed successfully")

            # Emit signal to trigger post-processing and next stage
            self.houdini_finished.emit()
        else:
            self.logger.error(f"✗ Houdini failed with code {exit_code}")
            self.console_widget.append(f"<span style='color:red'>✗ Houdini failed with code {exit_code}</span>")
            self._handle_houdini_error(exit_code)

    @Slot(QProcess.ProcessError)
    def _on_houdini_error(self, error):
        """Called if process fails to start or crashes - includes recovery strategies"""
        error_map = {
            QProcess.FailedToStart: "Failed to start (executable not found or permissions)",
            QProcess.Crashed: "Process crashed during execution",
            QProcess.Timedout: "Process timed out",
            QProcess.WriteError: "Error writing to process",
            QProcess.ReadError: "Error reading from process",
            QProcess.UnknownError: "Unknown error occurred"
        }

        error_msg = error_map.get(error, "Unknown error")
        self.logger.error(f"Houdini process error: {error_msg}")
        self.console_widget.append(f"<span style='color:red'>✗ {error_msg}</span>")
        
        # Recovery strategies based on error type
        if error == QProcess.FailedToStart:
            # Common issue: Executable not in PATH or environment not loaded
            exe_path = self._houdini_process.program()
            self.logger.error(f"  Attempted to run: {exe_path}")
            self.logger.error(f"  Check that houdini.env PATH is correct")
            self.logger.error(f"  Expected: {BP_HYTHON}")
            
            # Could offer to fix PATH automatically or open environment config
            
        elif error == QProcess.Crashed:
            # Retry once for transient failures (memory spikes, OS issues)
            if self._houdini_retry_count_this_run < 1:
                self._houdini_retry_count_this_run += 1
                self.logger.warning("Houdini crashed - retrying once (transient failure?)...")
                self.console_widget.append("<span style='color:orange'>⟳ Retrying...</span>")
                
                # Wait a moment for resources to clear
                QTimer.singleShot(2000, self._start_houdini_qprocess)
                return
            else:
                self.logger.error("Houdini crashed again after retry - aborting pipeline")
                self._handle_pipeline_error()
        
        else:
            # Other errors - abort pipeline
            self._handle_pipeline_error()

    @Slot()
    def houdini_post(self):
        """
        Post-process Houdini outputs and start next stage.
        Called via signal when Houdini completes.
        """
        self.logger.info("Post-processing Houdini outputs...")

        # Validate output files
        output_dir = Path(BP_HOUDINI_OUTPUT_DIR)
        low_poly_files = list(output_dir.glob("*_low.fbx"))

        if not low_poly_files:
            self.logger.error("No low-poly files found in output directory")
            self.console_widget.append("<span style='color:red'>✗ No outputs found</span>")
            self._handle_pipeline_error()
            return

        self.logger.info(f"Found {len(low_poly_files)} low-poly files")
        self.console_widget.append(f"  Found {len(low_poly_files)} files to process")

        # Start next stage
        self._start_substance_qprocess()

# Advantages of this approach:
# 1. No threading - single main thread + Qt's event loop
# 2. Real-time output streaming (instant console updates)
# 3. UI fully responsive throughout
# 4. Clean signal-based flow
# 5. No race conditions
# 6. Embedded console (no separate window)
# 7. Qt manages concurrency automatically
# 8. More maintainable code

from PySide6.QtCore import QTimer, QProcess, Slot
from PySide6.QtWidgets import QTextEdit
from pathlib import Path

class BP_HighToGameReadyTool(BP_BaseToolWindow):
    def __init__(self):
        super().__init__()
        self._pipeline_cancelled = False
        
        # Connect Cancel button
        self.cancel_button.clicked.connect(self.cancel_pipeline)
    
    def cancel_pipeline(self):
        """User clicked Cancel - gracefully terminate running processes"""
        self._pipeline_cancelled = True
        self.logger.warning("Pipeline cancellation requested...")
        self.console_widget.append("<span style='color:orange'>⚠ Cancelling pipeline...</span>")
        
        # Terminate active processes gracefully
        self._terminate_process(self._houdini_process, "Houdini")
        self._terminate_process(self._substance_process, "Substance")
        self._terminate_process(self._maya_process, "Maya")
        
        # Re-enable UI
        self._set_controls_enabled(True)
        self.console_widget.append("<span style='color:red'>✗ Pipeline cancelled by user</span>")
    
    def _terminate_process(self, process, name):
        """Gracefully terminate a QProcess"""
        if process and process.state() == QProcess.Running:
            self.logger.info(f"Terminating {name} process (PID: {process.processId()})...")
            
            # Step 1: Try graceful shutdown (SIGTERM on Unix, close on Windows)
            process.terminate()
            
            # Step 2: Wait up to 5 seconds for graceful exit
            if not process.waitForFinished(5000):  # 5 second timeout
                self.logger.warning(f"{name} did not terminate gracefully, forcing kill...")
                
                # Step 3: Force kill if still running (SIGKILL on Unix)
                process.kill()
                
                # Step 4: Wait for kill to complete
                process.waitForFinished(1000)
            
            self.logger.info(f"{name} process terminated")
    
    @Slot(int, QProcess.ExitStatus)
    def _on_houdini_finished(self, exit_code, exit_status):
        """Check for cancellation before continuing pipeline"""
        # If user cancelled, don't continue to next stage
        if self._pipeline_cancelled:
            self.logger.info("Houdini finished, but pipeline was cancelled")
            return
        
        # Normal completion logic
        if exit_code == 0 and exit_status == QProcess.NormalExit:
            self.logger.info("✓ Houdini completed successfully")
            self.houdini_finished.emit()
        else:
            self.logger.error(f"✗ Houdini failed with code {exit_code}")
            self._handle_houdini_error(exit_code)

import logging as _logging
_MODULENAME = 'co3dex.posts.threading_antipatterns'
_LOGGER = _logging.getLogger(_MODULENAME)
_LOGGER.info(f'Initializing: {_MODULENAME} ... threading != parallelism, QProcess > threading for subprocesses')