# Asset Processor GUI Development Plan

This document outlines the plan for developing a Graphical User Interface (GUI) for the Asset Processor Tool.

**I. Foundation & Framework Choice**

1.  **Choose GUI Framework:** PySide6 (LGPL license, powerful features).
2.  **Project Structure:** Create `gui/` directory. Core logic remains separate.
3.  **Dependencies:** Add `PySide6` to `requirements.txt`.

**II. Core GUI Layout & Basic Functionality**

1.  **Main Window:** `gui/main_window.py`.
2.  **Layout Elements:**
    *   Drag & Drop Area (`QWidget` subclass).
    *   Preset Dropdown (`QComboBox`).
    *   Preview Area (`QListWidget`).
    *   Progress Bar (`QProgressBar`).
    *   Control Buttons (`QPushButton`: Start, Cancel, Manage Presets).
    *   Status Bar (`QStatusBar`).

**III. Input Handling & Predictive Preview**

1.  **Connect Drag & Drop:** Validate drops, add valid paths to Preview List.
2.  **Refactor for Prediction:** Create/refactor methods in `AssetProcessor`/`Configuration` to predict output names without full processing.
3.  **Implement Preview Update:** On preset change or file add, load config, call prediction logic, update Preview List items (e.g., "Input: ... -> Output: ...").
4.  **Responsive Preview:** Utilize PySide6 list widget efficiency (consider model/view for very large lists).

**IV. Processing Integration & Progress Reporting**

1.  **Adapt Processing Logic:** Refactor `main.py`'s `ProcessPoolExecutor` loop into a callable function/class (`gui/processing_handler.py`).
2.  **Background Execution:** Run processing logic in a `QThread` to keep GUI responsive.
3.  **Progress Updates (Signals & Slots):**
    *   Background thread emits signals: `progress_update(current, total)`, `file_status_update(path, status, msg)`, `processing_finished(stats)`.
    *   Main window connects slots to these signals to update UI elements (`QProgressBar`, `QListWidget` items, status bar).
4.  **Completion/Error Handling:** Re-enable controls, display summary stats, report errors on `processing_finished`.

**V. Preset Management Interface (Sub-Task)**

1.  **New Window/Dialog:** `gui/preset_editor.py`.
2.  **Functionality:** List, load, edit (tree view/form), create, save/save as presets (`.json` in `presets/`). Basic validation.

**VI. Refinements & Additional Features (Ideas)**

1.  **Cancel Button:** Implement cancellation signal to background thread/workers.
2.  **Log Viewer:** Add `QTextEdit` to display `logging` output.
3.  **Output Directory Selection:** Add browse button/field.
4.  **Configuration Options:** Expose key `config.py` settings.
5.  **Clearer Error Display:** Tooltips, status bar updates, or error panel.

**VII. Packaging (Deployment)**

1.  **Tooling:** PyInstaller or cx_Freeze.
2.  **Configuration:** Build scripts (`.spec`) to bundle code, dependencies, assets, and `presets/`.

**High-Level Mermaid Diagram:**

```mermaid
graph TD
    subgraph GUI Application (PySide6)
        A[Main Window] --> B(Drag & Drop Area);
        A --> C(Preset Dropdown);
        A --> D(Preview List Widget);
        A --> E(Progress Bar);
        A --> F(Start Button);
        A -- Contains --> SB(Status Bar);
        A --> CB(Cancel Button);
        A --> MB(Manage Presets Button);

        B -- fileDroppedSignal --> X(Handle Input Files);
        C -- currentIndexChangedSignal --> Y(Update Preview);
        X -- Adds paths --> D;
        X -- Triggers --> Y;

        Y -- Reads --> C;
        Y -- Uses --> J(Prediction Logic);
        Y -- Updates --> D;

        F -- clickedSignal --> Z(Start Processing);
        CB -- clickedSignal --> AA(Cancel Processing);
        MB -- clickedSignal --> L(Preset Editor Dialog);

        Z -- Starts --> BB(Processing Thread: QThread);
        AA -- Signals --> BB;

        BB -- progressSignal(curr, total) --> E;
        BB -- fileStatusSignal(path, status, msg) --> D;
        BB -- finishedSignal(stats) --> AB(Handle Processing Finished);
        AB -- Updates --> SB;
        AB -- Enables/Disables --> F;
        AB -- Enables/Disables --> CB;
        AB -- Enables/Disables --> C;
        AB -- Enables/Disables --> B;

        L -- Modifies --> H(Presets Dir: presets/*.json);
    end

    subgraph Backend Logic (Existing + Refactored)
        H -- Loaded by --> C;
        H -- Loaded/Saved by --> L;

        J -- Reads --> M(configuration.py / asset_processor.py);
        BB -- Runs --> K(Adapted main.py Logic);
        K -- Uses --> N(ProcessPoolExecutor);
        N -- Runs --> O(process_single_asset_wrapper);
        O -- Uses --> M;
        O -- Reports Status --> K;
        K -- Reports Progress --> BB;
    end

    classDef gui fill:#f9f,stroke:#333,stroke-width:2px;
    classDef backend fill:#ccf,stroke:#333,stroke-width:2px;
    classDef thread fill:#ffc,stroke:#333,stroke-width:1px;
    class A,B,C,D,E,F,CB,MB,L,SB,X,Y,Z,AA,AB gui;
    class H,J,K,M,N,O backend;
    class BB thread;
```

This plan provides a roadmap for the GUI development.