# gui/asset_restructure_handler.py import logging from PySide6.QtCore import QObject, Slot, QModelIndex from PySide6.QtGui import QColor # Might be needed if copying logic directly, though unlikely now from pathlib import Path from .unified_view_model import UnifiedViewModel # Use relative import from rule_structure import SourceRule, AssetRule, FileRule log = logging.getLogger(__name__) class AssetRestructureHandler(QObject): """ Handles the model restructuring logic triggered by changes to FileRule target asset overrides in the UnifiedViewModel. """ def __init__(self, model: UnifiedViewModel, parent=None): super().__init__(parent) if not isinstance(model, UnifiedViewModel): raise TypeError("AssetRestructureHandler requires a UnifiedViewModel instance.") self.model = model log.debug("AssetRestructureHandler initialized.") @Slot(QModelIndex, object) def handle_target_asset_override(self, index: QModelIndex, new_target_path: object): """ Slot connected to UnifiedViewModel.targetAssetOverrideChanged. Orchestrates model changes based on the new target asset path. Args: index: The QModelIndex of the FileRule whose override changed. new_target_path: The new target asset path (string or None). """ log.debug(f"Handler received targetAssetOverrideChanged: Index=({index.row()},{index.column()}), New Path='{new_target_path}'") if not index.isValid(): log.warning("Handler received invalid index. Aborting.") return file_item = self.model.getItem(index) if not isinstance(file_item, FileRule): log.warning(f"Handler received index for non-FileRule item: {type(file_item)}. Aborting.") return # Ensure new_target_path is a string or None new_target_name = str(new_target_path).strip() if new_target_path is not None else None if new_target_name == "": new_target_name = None # Treat empty string as None # --- Get necessary context --- old_parent_asset = getattr(file_item, 'parent_asset', None) if not old_parent_asset: log.error(f"Handler: File item '{Path(file_item.file_path).name}' has no parent asset. Cannot restructure.") # Note: Data change already happened in setData, cannot easily revert here. return source_rule = getattr(old_parent_asset, 'parent_source', None) if not source_rule: log.error(f"Handler: Could not find SourceRule for parent asset '{old_parent_asset.asset_name}'. Cannot restructure.") return # --- Logic based on the new target name --- target_parent_asset = None target_parent_index = QModelIndex() move_occurred = False # 1. Find existing target parent AssetRule within the same SourceRule if new_target_name: for i, asset in enumerate(source_rule.assets): if asset.asset_name == new_target_name: target_parent_asset = asset # Get index for the target parent try: source_rule_row = self.model._source_rules.index(source_rule) source_rule_index = self.model.createIndex(source_rule_row, 0, source_rule) target_parent_index = self.model.index(i, 0, source_rule_index) if not target_parent_index.isValid(): log.error(f"Handler: Failed to create valid index for existing target parent '{new_target_name}'.") target_parent_asset = None # Reset if index is invalid except ValueError: log.error(f"Handler: Could not find SourceRule index while looking for target parent '{new_target_name}'.") target_parent_asset = None # Reset if index is invalid break # Found the asset # 2. Handle Move or Creation if target_parent_asset: # --- Move to Existing Parent --- if target_parent_asset != old_parent_asset: log.info(f"Handler: Moving file '{Path(file_item.file_path).name}' to existing asset '{target_parent_asset.asset_name}'.") if self.model.moveFileRule(index, target_parent_index): move_occurred = True else: log.error(f"Handler: Model failed to move file rule to existing asset '{target_parent_asset.asset_name}'.") # Consider how to handle failure - maybe log and continue to cleanup? else: # Target is the same as the old parent. No move needed. log.debug(f"Handler: Target asset '{new_target_name}' is the same as the current parent. No move required.") pass # No move needed, but might still need cleanup if old parent becomes empty later (unlikely in this specific case) elif new_target_name: # Only create if a *new* specific target name was given # --- Create New Parent AssetRule and Move --- log.info(f"Handler: Creating new asset '{new_target_name}' and moving file '{Path(file_item.file_path).name}'.") # Create the new asset rule using the model's method new_asset_index = self.model.createAssetRule(source_rule, new_target_name, copy_from_asset=old_parent_asset) if new_asset_index.isValid(): # Now move the file to the newly created asset if self.model.moveFileRule(index, new_asset_index): move_occurred = True target_parent_asset = new_asset_index.internalPointer() # Update for cleanup check else: log.error(f"Handler: Model failed to move file rule to newly created asset '{new_target_name}'.") # If move fails after creation, should we remove the created asset? Maybe. # For now, just log the error. else: log.error(f"Handler: Model failed to create new asset rule '{new_target_name}'. Cannot move file.") else: # new_target_name is None or empty # --- Moving back to original/default parent (Clearing Override) --- # The file *should* already be under its original parent if the override was just cleared. # However, if it was previously moved *away* from its original parent due to an override, # clearing the override *should* ideally move it back. # This logic is complex: we need to know the *original* parent before any overrides. # The current structure doesn't explicitly store this. # For now, assume clearing the override means it stays in its *current* parent, # and we only handle cleanup if that parent becomes empty. # A more robust solution might involve finding the asset matching the file's *directory* name. log.debug(f"Handler: Target asset override cleared for '{Path(file_item.file_path).name}'. File remains in parent '{old_parent_asset.asset_name}'.") # No move occurs in this simplified interpretation. # 3. Cleanup Empty Old Parent (only if a move occurred) # Check the old_parent_asset *after* the potential move if move_occurred and old_parent_asset and not old_parent_asset.files: log.info(f"Handler: Attempting to remove empty old parent asset '{old_parent_asset.asset_name}'.") if not self.model.removeAssetRule(old_parent_asset): log.warning(f"Handler: Model failed to remove empty old parent asset '{old_parent_asset.asset_name}'.") elif move_occurred: log.debug(f"Handler: Old parent asset '{old_parent_asset.asset_name}' still contains files. No removal needed.") log.debug(f"Handler finished processing targetAssetOverrideChanged for '{Path(file_item.file_path).name}'.")