visagevault.py

# ==============================================================================
# PROYECTO: VisageVault - Gestor de Fotografías Inteligente
# VERSIÓN: 1.6.16
# DERECHOS DE AUTOR: © 2025 Daniel Serrano Armenta
# ==============================================================================
#
# Autor: Daniel Serrano Armenta
# Contacto: anabasasoft@gmail.com
# GitHub: github.com/anabasasoft
# Portafolio: https://danitxu79.github.io/
#
# ## 📜 Licencia
#
# Este proyecto se ofrece bajo un modelo de **Doble Licencia (Dual License)**:
#
# 1.  **LGPLv3:** Ideal para proyectos de código abierto. Si usas esta biblioteca (especialmente
#  si la modificas), debes cumplir con las obligaciones de la LGPLv3.
# 2.  **Comercial (Privativa):** Si los términos de la LGPLv3 no se ajustan a tus necesidades
#  (por ejemplo, para software propietario de código cerrado), por favor contacta al autor para
#  adquirir una licencia comercial.
#
# Para más detalles, consulta el archivo `LICENSE` o la cabecera de `visagevault.py`.
#
#
# ==============================================================================

import sys
import os
from pathlib import Path
import datetime
import locale
import warnings
import sqlite3
import time

import threading # Necesario para evitar que la UI se congele
from drive_auth import DriveAuthenticator
import requests # Para bajar thumbnails
from drive_manager import DriveManager
import config_manager # Para guardar la carpeta elegida

# --- Silenciar solo el aviso de pkg_resources ---
warnings.filterwarnings(
    "ignore",
    message=r"pkg_resources is deprecated as an API",
    category=UserWarning,
)

import numpy as np
from sklearn.cluster import DBSCAN
import sklearn
import rawpy # Importar rawpy para soporte RAW
import cv2

from PySide6.QtWidgets import (
    QDialog, QTableWidget, QTableWidgetItem,
    QAbstractItemView, QHeaderView, QDialogButtonBox, QTreeWidget, QTreeWidgetItem,
    QComboBox, QMenu, QListWidget, QListWidgetItem, QFrame, QMessageBox
)

from PySide6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QPushButton, QLineEdit, QStyle, QFileDialog,
    QScrollArea, QGridLayout, QLabel, QGroupBox, QSpacerItem, QSizePolicy,
    QSplitter, QTabWidget, QStackedWidget, QSplashScreen
)
from PySide6.QtCore import (
    Qt, QSize, QObject, Signal, QThread, Slot, QTimer,
    QRunnable, QThreadPool, QPropertyAnimation, QEasingCurve, QRect, QPoint, QRectF,
    QPointF, QBuffer, QIODevice, QUrl, QEventLoop, QEvent
)
from PySide6.QtGui import (
    QPixmap, QIcon, QCursor, QTransform, QPainter, QPaintEvent,
    QPainterPath, QKeyEvent, QDesktopServices, QImage, QColor, QPen, QBrush
)

# --- MODIFICADO: Importar las funciones de foto Y vídeo ---
from photo_finder import find_photos, find_videos
import config_manager
from metadata_reader import get_photo_date, get_video_date
from thumbnail_generator import (
    generate_image_thumbnail, generate_video_thumbnail, THUMBNAIL_SIZE
)
# --- FIN DE MODIFICACIÓN ---

import metadata_reader
import piexif.helper
import re
import db_manager
from db_manager import VisageVaultDB
import face_recognition
from PIL import Image
import ast
from concurrent.futures import ThreadPoolExecutor, as_completed
import pickle
import shutil
import hashlib
from functools import lru_cache

# =================================================================
# EXTRACTOR DE FECHA POR NOMBRE DE ARCHIVO
# =================================================================
def parse_date_from_filename(filepath):
    """
    Intenta extraer la fecha (Año, Mes) basándose exclusivamente en el nombre del archivo.
    Soporta: YYYYMMDD, DD-MM-YYYY, YYYY-MM-DD, DDMMYYYY.
    """
    filename = os.path.basename(filepath)

    # 1. Patrón YYYYMMDD (Ej: IMG-20250304-..., VID-20240411..., 20231005.jpg)
    # Busca 20xx seguido de mes (01-12) y día (01-31)
    match = re.search(r'(20\d{2})(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])', filename)
    if match:
        return match.group(1), match.group(2) # Retorna (Año, Mes)

    # 2. Patrón DD-MM-YYYY o DD.MM.YYYY o DD_MM_YYYY (Ej: 07-10-2023.jpg)
    match = re.search(r'(0[1-9]|[12]\d|3[01])[-._](0[1-9]|1[0-2])[-._](20\d{2})', filename)
    if match:
        return match.group(3), match.group(2) # Retorna (Año, Mes)

    # 3. Patrón YYYY-MM-DD (Ej: 2023-11-01_Foto.jpg)
    match = re.search(r'(20\d{2})[-._](0[1-9]|1[0-2])[-._](0[1-9]|[12]\d|3[01])', filename)
    if match:
        return match.group(1), match.group(2)

    # 4. Patrón DDMMYYYY Compacto (Ej: IMG-04122021.jpg -> 04/12/2021)
    # Asume formato europeo DDMMYYYY si no hay separadores
    match = re.search(r'(0[1-9]|[12]\d|3[01])(0[1-9]|1[0-2])(20\d{2})', filename)
    if match:
        return match.group(3), match.group(2)

    return None, None

# --- FUNCIÓN GLOBAL DE CACHÉ EN RAM ---
# Guarda las últimas 500 imágenes en memoria para que el scroll sea instantáneo
@lru_cache(maxsize=500)
def get_cached_pixmap(filepath: str) -> QPixmap:
    if os.path.exists(filepath) and os.path.getsize(filepath) > 0:
        return QPixmap(filepath)
    return QPixmap()

def resource_path(relative_path):
    """Obtiene la ruta absoluta al recurso tanto en PyInstaller como en desarrollo."""
    if hasattr(sys, '_MEIPASS'):
        base_path = sys._MEIPASS
    else:
        base_path = os.path.dirname(os.path.abspath(__file__))
    return os.path.join(base_path, relative_path)

# --- Configuración regional para nombres de meses ---
try:
    locale.setlocale(locale.LC_TIME, '')
except locale.Error:
    print("Warning: Could not set system locale, month names may be in English.")


# Constante para el margen de precarga (en píxeles)
PRELOAD_MARGIN_PX = 500

# =================================================================
# DEFINICIÓN ÚNICA DE SEÑALES PARA EL THUMBNAILLOADER
# =================================================================
class ThumbnailLoaderSignals(QObject):
    """Contenedor de señales para la clase QRunnable."""
    thumbnail_loaded = Signal(str, QPixmap) # original_path, pixmap
    load_failed = Signal(str)

# =================================================================
# CLASE PARA CARGAR MINIATURAS DE IMAGEN (QRunnable)
# =================================================================
class ThumbnailLoader(QRunnable):
    def __init__(self, original_filepath: str, signals: ThumbnailLoaderSignals):
        super().__init__()
        self.original_filepath = original_filepath
        self.signals = signals

    @Slot()
    def run(self):
        # 1. Generar si no existe (esto escribe en disco)
        thumbnail_path = generate_image_thumbnail(self.original_filepath)

        if thumbnail_path:
            try:
                # 2. Cargar usando CACHÉ DE RAM (¡Mucho más rápido!)
                pixmap = get_cached_pixmap(thumbnail_path)
                if not pixmap.isNull():
                    self.signals.thumbnail_loaded.emit(self.original_filepath, pixmap)
                else:
                    self.signals.load_failed.emit(self.original_filepath)
            except Exception:
                self.signals.load_failed.emit(self.original_filepath)
        else:
            self.signals.load_failed.emit(self.original_filepath)

# =================================================================
# CLASE PARA CARGAR MINIATURAS DE VÍDEO (QRunnable) - ¡NUEVA!
# =================================================================
class VideoThumbnailLoader(QRunnable):
    def __init__(self, original_filepath: str, signals: ThumbnailLoaderSignals):
        super().__init__()
        self.original_filepath = original_filepath
        self.signals = signals

    @Slot()
    def run(self):
        thumbnail_path = generate_video_thumbnail(self.original_filepath)
        if thumbnail_path:
            try:
                # Usar Caché RAM
                pixmap = get_cached_pixmap(thumbnail_path)
                if not pixmap.isNull():
                    self.signals.thumbnail_loaded.emit(self.original_filepath, pixmap)
                else:
                    self.signals.load_failed.emit(self.original_filepath)
            except Exception:
                self.signals.load_failed.emit(self.original_filepath)
        else:
            self.signals.load_failed.emit(self.original_filepath)

# =================================================================
# CLASE: NetworkThumbnailLoader (CON CACHÉ EN DISCO)
# =================================================================
class NetworkThumbnailLoader(QRunnable):
    def __init__(self, url, file_id, signals):
        super().__init__()
        self.url = url
        self.file_id = file_id
        self.signals = signals

        base_dir = os.path.dirname(os.path.abspath(__file__))
        self.cache_dir = os.path.join(base_dir, "visagevault_cache", "drive_snapshot_cache")
        if not os.path.exists(self.cache_dir):
            try: os.makedirs(self.cache_dir)
            except: pass

    @Slot()
    def run(self):
        cache_path = os.path.join(self.cache_dir, f"{self.file_id}.jpg")

        # 1. INTENTO CACHÉ DISCO + RAM
        if os.path.exists(cache_path) and os.path.getsize(cache_path) > 0:
            pixmap = get_cached_pixmap(cache_path) # <--- RAM CACHE
            if not pixmap.isNull():
                self.signals.thumbnail_loaded.emit(self.file_id, pixmap)
                return

        # 2. DESCARGA
        if not self.url: return

        try:
            response = requests.get(self.url, timeout=10)
            if response.status_code == 200:
                with open(cache_path, 'wb') as f:
                    f.write(response.content)

                # Cargar en memoria y cachear
                pixmap = get_cached_pixmap(cache_path) # <--- Se guarda en LRU Cache al leer
                if not pixmap.isNull():
                    self.signals.thumbnail_loaded.emit(self.file_id, pixmap)
        except Exception:
            pass

class DriveFolderDialog(QDialog):
    def __init__(self, drive_manager, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Navegador de Google Drive")
        self.resize(600, 450)
        self.drive = drive_manager

        # Estado de navegación
        self.current_folder_id = None
        self.current_folder_name = None
        self.folder_history = []

        self.selected_folder_id = None
        self.selected_folder_name = None

        layout = QVBoxLayout(self)

        # 1. Cabecera con Ruta
        self.path_label = QLabel("Inicio")
        self.path_label.setStyleSheet("font-weight: bold; color: #3daee9; font-size: 14px; padding: 5px;")
        layout.addWidget(self.path_label)

        # --- NUEVO: AVISO INFORMATIVO ---
        info_layout = QHBoxLayout()
        info_icon = QLabel("ℹ️")
        info_text = QLabel("Esta lista <b>SOLO muestra carpetas</b>. Tus fotos no aparecerán aquí, pero se escanearán al pulsar 'Seleccionar'.")
        info_text.setWordWrap(True)
        info_text.setStyleSheet("color: gray; font-size: 11px;")
        info_layout.addWidget(info_icon)
        info_layout.addWidget(info_text, 1)
        layout.addLayout(info_layout)
        # --------------------------------

        # 2. Lista
        self.list_widget = QListWidget()
        self.list_widget.setIconSize(QSize(32, 32))
        self.list_widget.itemDoubleClicked.connect(self._on_item_double_clicked)
        layout.addWidget(self.list_widget)

        # 3. Botones
        btn_layout = QHBoxLayout()
        self.btn_select = QPushButton("Seleccionar esta carpeta")
        self.btn_select.setEnabled(False)
        self.btn_select.setStyleSheet("""
            QPushButton { background-color: #3daee9; color: white; font-weight: bold; padding: 10px; border-radius: 4px;}
            QPushButton:hover { background-color: #4dbef9; }
            QPushButton:disabled { background-color: #cccccc; }
        """)
        self.btn_select.clicked.connect(self._select_current)

        self.btn_cancel = QPushButton("Cancelar")
        self.btn_cancel.clicked.connect(self.reject)

        btn_layout.addWidget(self.btn_select)
        btn_layout.addWidget(self.btn_cancel)
        layout.addLayout(btn_layout)

        # CARGAR MENÚ INICIAL
        self._load_home_menu()

    def _load_home_menu(self):
        self.list_widget.clear()
        self.current_folder_id = "HOME"
        self.current_folder_name = "Inicio"
        self.path_label.setText("🏠 Inicio")
        self.btn_select.setText("Selecciona una opción...")
        self.btn_select.setEnabled(False)
        self.folder_history = []

        item_drive = QListWidgetItem("Mi Unidad")
        item_drive.setData(Qt.UserRole, "root")
        item_drive.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_DriveHDIcon))
        self.list_widget.addItem(item_drive)

        item_pc = QListWidgetItem("Ordenadores")
        item_pc.setData(Qt.UserRole, "computers")
        item_pc.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_ComputerIcon))
        self.list_widget.addItem(item_pc)

    def _load_folder(self, folder_id, folder_name):
        self.list_widget.clear()
        self.current_folder_id = folder_id
        self.current_folder_name = folder_name

        path_str = " > ".join([name for _, name in self.folder_history] + [folder_name])
        self.path_label.setText(path_str)

        self.btn_select.setEnabled(True)
        self.btn_select.setText(f"Seleccionar: '{folder_name}'")

        back_item = QListWidgetItem(".. (Volver)")
        back_item.setData(Qt.UserRole, "BACK")
        back_item.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_ArrowUp))
        back_item.setForeground(Qt.gray)
        self.list_widget.addItem(back_item)

        try:
            QApplication.setOverrideCursor(Qt.WaitCursor)
            folders = self.drive.list_folders(folder_id)
            QApplication.restoreOverrideCursor()

            # Si no hay carpetas, avisamos pero permitimos seleccionar
            if not folders:
                info_item = QListWidgetItem("(No hay subcarpetas)")
                info_item.setFlags(Qt.NoItemFlags) # No seleccionable
                self.list_widget.addItem(info_item)

            for f in folders:
                item = QListWidgetItem(f['name'])
                item.setData(Qt.UserRole, f['id'])
                item.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_DirIcon))
                self.list_widget.addItem(item)

        except Exception as e:
            QApplication.restoreOverrideCursor()
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Error", f"No se pudo listar: {e}")

    def _on_item_double_clicked(self, item):
        data = item.data(Qt.UserRole)
        if not data: return

        if data == "BACK":
            if self.folder_history:
                prev_id, prev_name = self.folder_history.pop()
                if prev_id == "HOME":
                    self._load_home_menu()
                else:
                    self._load_folder(prev_id, prev_name)
            else:
                self._load_home_menu()

        elif data == "root" or data == "computers":
            self.folder_history.append(("HOME", "Inicio"))
            self._load_folder(data, item.text())

        else:
            self.folder_history.append((self.current_folder_id, self.current_folder_name))
            self._load_folder(data, item.text())

    def _select_current(self):
        if self.current_folder_id == "HOME" or self.current_folder_id == "computers":
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.information(self, "Aviso", "Por favor, entra en una carpeta específica para seleccionarla.")
            return

        self.selected_folder_id = self.current_folder_id
        self.selected_folder_name = self.current_folder_name
        self.accept()

# =================================================================
# SEÑALES Y WORKER PARA CARGAR Y RECORTAR CARAS (Sin cambios)
# =================================================================
class FaceLoaderSignals(QObject):
    face_loaded = Signal(int, QPixmap, str)
    face_load_failed = Signal(int)

# =================================================================
# WORKER PARA LOGIN DE GOOGLE DRIVE
# =================================================================
class DriveLoginWorker(QObject):
    """Worker para manejar la autenticación de Google Drive en segundo plano."""
    login_success = Signal(object)  # Emite el servicio de Drive
    login_failed = Signal(str)      # Emite mensaje de error
    finished = Signal()

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

    @Slot()
    def run(self):
        try:
            from drive_auth import DriveAuthenticator
            auth = DriveAuthenticator()
            service = auth.get_service()
            self.login_success.emit(service)
        except FileNotFoundError as e:
            self.login_failed.emit(str(e))
        except Exception as e:
            print(f"Error de Login con Google: {e}")
            self.login_failed.emit(str(e))
        finally:
            self.finished.emit()

class FolderLoaderWorker(QObject):
    """
    Descarga la lista de subcarpetas de un directorio específico en segundo plano.
    """
    finished = Signal(list, QTreeWidgetItem) # Emite: (lista_carpetas, item_del_arbol_que_se_expande)

    def __init__(self, folder_id, parent_item):
        super().__init__()
        self.folder_id = folder_id
        self.parent_item = parent_item

    def run(self):
        try:
            # Instanciamos un manager independiente para este hilo
            from drive_manager import DriveManager
            manager = DriveManager()

            # Obtenemos carpetas (esto puede tardar 1-2 segundos)
            folders = manager.list_folders(self.folder_id)

            self.finished.emit(folders, self.parent_item)
        except Exception as e:
            print(f"Error cargando carpetas: {e}")
            self.finished.emit([], self.parent_item)

class DriveScanWorker(QObject):
    """
    Worker con capacidad de 'Modo Lento' para ceder prioridad a otras tareas.
    """
    progress = Signal(str)
    finished = Signal(int)

    def __init__(self, folder_id, db_path):
        super().__init__()
        self.folder_id = folder_id
        self.db_path = db_path
        self.is_running = True
        self.slow_mode = False # <--- NUEVA VARIABLE DE CONTROL

    @Slot(bool)
    def set_slow_mode(self, active):
        """Slot para activar/desactivar el modo de baja prioridad."""
        self.slow_mode = active
        if active:
            print("🐢 Worker Drive: Entrando en modo lento (Prioridad a carpetas)")
        else:
            print("🐇 Worker Drive: Volviendo a velocidad normal")

    @Slot()
    def run(self):
        local_db = VisageVaultDB(os.path.basename(self.db_path), is_worker=True)
        local_db.db_path = self.db_path
        local_db.conn = sqlite3.connect(self.db_path, check_same_thread=False)
        local_db.conn.execute("PRAGMA journal_mode=WAL;")
        local_db.conn.row_factory = sqlite3.Row

        try:
            from drive_manager import DriveManager
            local_manager = DriveManager()

            count = 0
            buffer = []
            BATCH_SIZE = 100
            last_update_time = time.time()

            for batch_of_images in local_manager.list_images_recursively(self.folder_id):
                if not self.is_running: break

                buffer.extend(batch_of_images)

                # --- AQUÍ ESTÁ LA MAGIA DE LA PRIORIDAD ---
                if self.slow_mode:
                    # Si estamos en modo lento, dormimos 1.5 segundos.
                    # Esto deja la red y la CPU libres para que el Árbol de Carpetas cargue rápido.
                    time.sleep(1.5)
                # ------------------------------------------

                if len(buffer) >= BATCH_SIZE:
                    self._save_to_db(local_db, buffer)
                    count += len(buffer)
                    buffer = []

                    if time.time() - last_update_time > 1.0:
                        self.progress.emit(f"Indexando nube... {count} fotos guardadas.")
                        last_update_time = time.time()

                    time.sleep(0.05) # Pausa normal

            if buffer:
                self._save_to_db(local_db, buffer)
                count += len(buffer)

            self.progress.emit(f"Finalizado. Total: {count} fotos.")
            self.finished.emit(count)

        except Exception as e:
            print(f"❌ ERROR FATAL EN WORKER DRIVE: {e}")
            import traceback
            traceback.print_exc()
            self.finished.emit(0)
        finally:
            try: local_db.conn.close()
            except: pass

    def _save_to_db(self, db_instance, items):
        try:
            db_instance.bulk_upsert_drive_photos(items, root_folder_id=self.folder_id)
        except Exception as e:
            print(f"Error guardando en DB Drive: {e}")

class FaceScanWorker(QObject):
    def __init__(self, db_path: str):
        super().__init__()
        self.db_path = db_path
        self.signals = FaceScanSignals()
        self.is_running = True

    @Slot()
    def run(self):
        # Configuración de la DB en el hilo
        local_db = VisageVaultDB(os.path.basename(self.db_path), is_worker=True)
        local_db.db_path = self.db_path
        local_db.conn = sqlite3.connect(self.db_path, check_same_thread=False)

        # --- CORRECCIÓN CRÍTICA ---
        local_db.conn.row_factory = sqlite3.Row  # <--- ¡ESTA ES LA LÍNEA QUE FALTABA!
        # --------------------------

        local_db.conn.execute("PRAGMA journal_mode=WAL;")

        try:
            self.signals.scan_progress.emit("Buscando fotos sin escanear...")

            # Ahora esto funcionará porque row_factory convierte las tuplas en objetos accesibles por nombre
            unscanned_photos = local_db.get_unscanned_photos()

            total = len(unscanned_photos)
            if total == 0:
                self.signals.scan_progress.emit("No hay fotos nuevas para analizar.")
                self.signals.scan_percentage.emit(100)
                self.signals.scan_finished.emit()
                return

            self.signals.scan_progress.emit(f"Escaneando {total} fotos nuevas para caras...")

            # Extensiones RAW
            RAW_EXTENSIONS = ('.nef', '.cr2', '.cr3', '.crw', '.arw', '.srf', '.orf', '.rw2', '.raf', '.pef', '.dng', '.raw')

            for i, row in enumerate(unscanned_photos):
                if not self.is_running: break

                # AQUÍ DABA EL ERROR ANTES: row['id'] fallaba sin row_factory
                photo_id = row['id']
                photo_path = row['filepath']

                # Actualizar barra de progreso con menos frecuencia (cada 5 fotos)
                if i % 5 == 0:
                    percentage = (i + 1) * 100 // total
                    self.signals.scan_percentage.emit(percentage)
                    self.signals.scan_progress.emit(f"Analizando caras ({i+1}/{total})...")
                    time.sleep(0.001)

                try:
                    image = None
                    file_suffix = Path(photo_path).suffix.lower()

                    # 1. Cargar Imagen (Soporte RAW + Standard)
                    if file_suffix in RAW_EXTENSIONS:
                        try:
                            with rawpy.imread(photo_path) as raw:
                                image = raw.postprocess()
                        except Exception:
                            local_db.mark_photo_as_scanned(photo_id)
                            continue
                    else:
                        image = face_recognition.load_image_file(photo_path)

                    if image is None:
                        local_db.mark_photo_as_scanned(photo_id)
                        continue

                    # 2. Optimización: Redimensionar si es gigante
                    h, w = image.shape[:2]
                    max_width = 1000
                    scale_ratio = 1.0

                    if w > max_width:
                        scale_ratio = max_width / float(w)
                        new_h = int(h * scale_ratio)
                        image = cv2.resize(image, (max_width, new_h))

                    # 3. Detectar caras
                    locations = face_recognition.face_locations(image)

                    if locations:
                        encodings = face_recognition.face_encodings(image, locations)

                        for loc, enc in zip(locations, encodings):
                            # Restaurar coordenadas originales si hubo redimensionado
                            if scale_ratio != 1.0:
                                top, right, bottom, left = loc
                                top = int(top / scale_ratio)
                                right = int(right / scale_ratio)
                                bottom = int(bottom / scale_ratio)
                                left = int(left / scale_ratio)
                                loc = (top, right, bottom, left)

                            location_str = str(loc)
                            encoding_blob = pickle.dumps(enc)

                            # Guardar cara encontrada
                            face_db_id = local_db.add_face(photo_id, encoding_blob, location_str)
                            self.signals.face_found.emit(face_db_id, photo_path, location_str)

                    # Marcar foto como procesada
                    local_db.mark_photo_as_scanned(photo_id)

                except Exception as e:
                    print(f"Error procesando caras en {photo_path}: {e}")
                    local_db.mark_photo_as_scanned(photo_id)

            self.signals.scan_progress.emit("Escaneo de caras finalizado.")
            self.signals.scan_finished.emit()

        except Exception as e:
            print(f"Error crítico worker caras: {e}")
            self.signals.scan_progress.emit(f"Error: {e}")
            self.signals.scan_finished.emit()
        finally:
            local_db.conn.close()

# =================================================================
# CLASE: FaceLoader (CORREGIDA PARA RUTAS LINUX)
# =================================================================
class FaceLoader(QRunnable):
    def __init__(self, signals: FaceLoaderSignals, face_id: int, photo_path: str, location_str: str):
        super().__init__()
        self.signals = signals
        self.face_id = face_id
        self.photo_path = photo_path
        self.location_str = location_str

        # --- CORRECCIÓN DE RUTA ---
        # Detectar si estamos en modo sistema (Linux instalado) o portable
        base_dir = os.path.dirname(os.path.abspath(__file__))

        if os.access(base_dir, os.W_OK):
            # Modo Desarrollo / Windows
            self.cache_dir = os.path.join(base_dir, "visagevault_cache", "face_cache")
        else:
            # Modo Linux Instalado (AUR) -> Usar ~/.cache
            user_home = os.path.expanduser("~")
            self.cache_dir = os.path.join(user_home, ".cache", "visagevault", "face_cache")
        # --------------------------

        if not os.path.exists(self.cache_dir):
            try: os.makedirs(self.cache_dir, exist_ok=True)
            except: pass

        self.cache_path = os.path.join(self.cache_dir, f"face_{self.face_id}.jpg")

    @Slot()
    def run(self):
        try:
            pixmap = QPixmap()

            # 1. INTENTO DE CARGA RÁPIDA (CACHÉ)
            if os.path.exists(self.cache_path):
                if pixmap.load(self.cache_path):
                    try:
                        self.signals.face_loaded.emit(self.face_id, pixmap, self.photo_path)
                    except RuntimeError:
                        pass # Ignorar si la app se cerró mientras cargábamos
                    return

            # 2. SI NO EXISTE CACHÉ: PROCESO LENTO (Abrir original y recortar)
            location = ast.literal_eval(self.location_str)
            (top, right, bottom, left) = location

            RAW_EXTENSIONS = ('.nef', '.cr2', '.cr3', '.crw', '.arw', '.srf', '.orf', '.rw2', '.raf', '.pef', '.dng', '.raw')
            file_suffix = Path(self.photo_path).suffix.lower()

            img = None

            if file_suffix in RAW_EXTENSIONS:
                try:
                    with rawpy.imread(self.photo_path) as raw:
                        rgb_array = raw.postprocess()
                        img = Image.fromarray(rgb_array)
                except Exception as e:
                    # print(f"Error rawpy en FaceLoader: {e}")
                    raise e
            else:
                img = Image.open(self.photo_path)

            if img is None:
                raise Exception("No se pudo cargar la imagen base")

            # Recortar la cara
            face_image_pil = img.crop((left, top, right, bottom))

            # 3. GUARDAR EN CACHÉ
            try:
                if face_image_pil.mode != "RGB":
                    face_image_pil = face_image_pil.convert("RGB")
                face_image_pil.save(self.cache_path, "JPEG", quality=90)
            except Exception as e:
                print(f"No se pudo guardar caché para cara {self.face_id}: {e}")

            # 4. Convertir a QPixmap
            buffer = QBuffer()
            buffer.open(QIODevice.OpenModeFlag.ReadWrite)
            face_image_pil.save(buffer, "PNG")
            pixmap.loadFromData(buffer.data())
            buffer.close()

            if pixmap.isNull():
                raise Exception("QPixmap nulo después de la conversión.")

            # --- PROTECCIÓN CONTRA CIERRE ---
            try:
                self.signals.face_loaded.emit(self.face_id, pixmap, self.photo_path)
            except RuntimeError:
                pass # App cerrada, no hacer nada

        except Exception as e:
            # Si falla, emitimos señal de fallo, pero también protegida
            try:
                self.signals.face_load_failed.emit(self.face_id)
            except RuntimeError:
                pass # App cerrada

# =================================================================
# SEÑALES Y WORKER PARA AGRUPAR CARAS (CLUSTERING) (Sin cambios)
# =================================================================
class ClusterSignals(QObject):
    clusters_found = Signal(list)
    clustering_progress = Signal(str)
    clustering_finished = Signal()

class ClusterWorker(QRunnable):
    def __init__(self, signals: ClusterSignals, db_path: str):
        super().__init__()
        self.signals = signals
        self.db_path = db_path

    @Slot()
    def run(self):
        local_db = VisageVaultDB(os.path.basename(self.db_path), is_worker=True)
        local_db.db_path = self.db_path
        local_db.conn = sqlite3.connect(self.db_path, check_same_thread=False)
        local_db.conn.row_factory = sqlite3.Row

        try:
            self.signals.clustering_progress.emit("Cargando datos de caras...")
            face_data = local_db.get_unknown_face_encodings()

            if len(face_data) < 2:
                self.signals.clustering_progress.emit("No hay suficientes caras para comparar.")
                self.signals.clusters_found.emit([])
                self.signals.clustering_finished.emit()
                return

            # ... (Resto de lógica igual que antes) ...

            self.signals.clustering_progress.emit(f"Comparando {len(face_data)} caras...")
            face_ids = [data[0] for data in face_data]
            encodings = np.array([data[1] for data in face_data])

            clt = DBSCAN(eps=0.4, min_samples=2, metric="euclidean")
            clt.fit(encodings)

            clusters = {}
            for face_id, label in zip(face_ids, clt.labels_):
                if label == -1:
                    continue
                if label not in clusters:
                    clusters[label] = []
                clusters[label].append(face_id)

            final_clusters_list = list(clusters.values())
            self.signals.clustering_progress.emit(f"Se encontraron {len(final_clusters_list)} grupos.")
            self.signals.clusters_found.emit(final_clusters_list)

        except Exception as e:
            print(f"Error crítico en el ClusterWorker: {e}")
            self.signals.clustering_progress.emit(f"Error: {e}")
        finally:
            local_db.conn.close()
            self.signals.clustering_finished.emit()

# =================================================================
# CLASE PARA MOSTRAR CARAS RECORTADAS (Sin cambios)
# =================================================================
class CircularFaceLabel(QLabel):
    clicked = Signal()
    rightClicked = Signal(QPoint)
    def __init__(self, pixmap: QPixmap, parent=None):
        super().__init__(parent)
        self.setFixedSize(100, 100)
        self.setCursor(Qt.PointingHandCursor)
        self.setToolTip("Cara detectada (Haz clic para etiquetar)")
        self.setAlignment(Qt.AlignCenter)
        self._pixmap = QPixmap()
        if pixmap and not pixmap.isNull():
            self.setPixmap(pixmap)
    def setPixmap(self, pixmap: QPixmap):
        if pixmap.isNull():
            self._pixmap = QPixmap()
        else:
            self._pixmap = pixmap.scaled(100, 100, Qt.KeepAspectRatioByExpanding, Qt.SmoothTransformation)
        self.update()
    def paintEvent(self, event: QPaintEvent):
        if self._pixmap.isNull():
            super().paintEvent(event)
            return
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
        path = QPainterPath()
        path.addEllipse(0, 0, self.width(), self.height())
        painter.setClipPath(path)
        painter.drawPixmap(0, 0, self._pixmap)
        painter.end()
    def mousePressEvent(self, event):
        if event.button() == Qt.LeftButton:
            self.clicked.emit()
        elif event.button() == Qt.RightButton:
            self.rightClicked.emit(event.globalPos())
        super().mousePressEvent(event)

# =================================================================
# CLASE: ZoomableClickableLabel (Corregida)
# =================================================================
class ZoomableClickableLabel(QLabel):
    doubleClickedPath = Signal(str)

    def __init__(self, original_path=None, parent=None):
        super().__init__(parent)
        self.original_path = original_path
        self.setAlignment(Qt.AlignCenter)
        self.setMouseTracking(True)
        self._original_pixmap = QPixmap()
        self._current_scale = 1.0
        self._scale_factor = 1.15
        self._view_offset = QPointF(0.0, 0.0)
        self._panning = False
        self._last_mouse_pos = QPoint()
        self.is_thumbnail_view = False
        self.setCursor(Qt.OpenHandCursor)

    def setOriginalPixmap(self, pixmap: QPixmap):
        if pixmap.isNull():
            self._original_pixmap = QPixmap()
        else:
            self._original_pixmap = pixmap

        # Reseteamos variables
        self._current_scale = 1.0
        self._view_offset = QPointF(0.0, 0.0)

        # ¡IMPORTANTE! Calcular el ajuste inicial inmediatamente
        self.fitToWindow()

    def fitToWindow(self):
        """Ajusta la imagen para que quepa perfectamente en la ventana."""
        if self._original_pixmap.isNull():
            return

        # --- CORRECCIÓN: Obtener dimensiones reales disponibles ---
        # Si el label aún no se ha "estirado" (ancho < 100), usamos el tamaño de la ventana padre.
        # Esto soluciona que la foto salga minúscula al abrirse.
        view_width = self.width()
        view_height = self.height()

        if view_width < 100 and self.window():
            view_width = self.window().width()
            view_height = self.window().height()

        if view_width <= 0 or view_height <= 0: return

        # Calculamos ratios usando esas dimensiones corregidas
        x_ratio = view_width / self._original_pixmap.width()
        y_ratio = view_height / self._original_pixmap.height()

        # Ajustamos la escala para que ocupe el MÁXIMO posible (llenar pantalla)
        self._current_scale = min(x_ratio, y_ratio)

        # Centramos
        self._view_offset = QPointF(0, 0)

        # Aplicamos límites y actualizamos
        self._clamp_view_offset()
        self.update()

    def wheelEvent(self, event):
        if event.modifiers() == Qt.ControlModifier:
            if self.is_thumbnail_view:
                if event.angleDelta().y() < 0:
                    self._open_preview()
                else:
                    super().wheelEvent(event)
            else:
                if event.angleDelta().y() > 0:
                    # Intentar cerrar si es el visor
                    win = self.window()
                    if win.property("is_lightbox"):
                        win.close_with_animation()
            return
        if self.is_thumbnail_view:
            super().wheelEvent(event)
            return
        if self._original_pixmap.isNull():
            return
        old_scale = self._current_scale
        if event.angleDelta().y() > 0:
            self._current_scale *= self._scale_factor
        else:
            self._current_scale /= self._scale_factor
        mouse_pos_in_label = event.position()
        original_img_coords_before_zoom = QPointF(
            self._view_offset.x() + (mouse_pos_in_label.x() / old_scale),
            self._view_offset.y() + (mouse_pos_in_label.y() / old_scale)
        )
        self._view_offset = QPointF(
            original_img_coords_before_zoom.x() - (mouse_pos_in_label.x() / self._current_scale),
            original_img_coords_before_zoom.y() - (mouse_pos_in_label.y() / self._current_scale)
        )
        self._clamp_view_offset()
        self.update()

    def mousePressEvent(self, event):
        # Si estamos en modo miniatura, el comportamiento es el estándar
        if self.is_thumbnail_view:
            super().mousePressEvent(event)
            return

        # --- LÓGICA DE DETECCIÓN DE CLIC EN ZONA NEGRA ---
        if event.button() == Qt.LeftButton:
            # 1. Calcular tamaño visual real de la imagen escalada
            scaled_w = self._original_pixmap.width() * self._current_scale
            scaled_h = self._original_pixmap.height() * self._current_scale

            # 2. Calcular dónde empieza la imagen (centrado)
            # Si la imagen es más pequeña que la ventana, hay margen (x > 0).
            # Si es más grande, ocupa todo (x = 0).
            x_start = (self.width() - scaled_w) / 2 if scaled_w < self.width() else 0
            y_start = (self.height() - scaled_h) / 2 if scaled_h < self.height() else 0

            # 3. Crear el rectángulo que ocupa la imagen REALMENTE en pantalla
            # Usamos el ancho/alto visual o el de la ventana (el que sea menor) para definir el área clicable válida
            valid_w = min(scaled_w, self.width())
            valid_h = min(scaled_h, self.height())

            # Ajuste: Si la imagen es gigante (zoom), el rect válido es toda la pantalla
            img_rect = QRectF(x_start, y_start, scaled_w, scaled_h)

            # 4. Comprobar si el clic está DENTRO de la imagen
            if not img_rect.contains(event.position()):
                # ¡CLIC EN LO NEGRO! -> Ignoramos el evento.
                # Esto hará que Qt se lo pase automáticamente al padre (ImagePreviewDialog)
                event.ignore()
                return

            # Si llegamos aquí, el clic fue DENTRO de la imagen -> Iniciamos Paneo (arrastrar)
            self._panning = True
            self._last_mouse_pos = event.position().toPoint()
            self.setCursor(Qt.ClosedHandCursor)
            event.accept() # Marcamos que hemos usado el evento

    def mouseMoveEvent(self, event):
        if self._panning and not self.is_thumbnail_view:
            # Calculamos cuánto se ha movido el ratón
            delta = event.position().toPoint() - self._last_mouse_pos
            self._last_mouse_pos = event.position().toPoint()

            # Ajustamos el offset inversamente al movimiento y ajustado a la escala
            # (Si muevo ratón a la derecha, quiero ver la parte izquierda de la foto -> resto X)
            self._view_offset.setX(self._view_offset.x() - (delta.x() / self._current_scale))
            self._view_offset.setY(self._view_offset.y() - (delta.y() / self._current_scale))

            self._clamp_view_offset()
            self.update()
        else:
            super().mouseMoveEvent(event)

    def mouseReleaseEvent(self, event):
        if event.button() == Qt.LeftButton and not self.is_thumbnail_view:
            self._panning = False
            self.setCursor(Qt.OpenHandCursor)
        super().mouseReleaseEvent(event)

    def mouseDoubleClickEvent(self, event):
        # Si es miniatura, emitimos la señal para abrir el visor
        if self.is_thumbnail_view and self.original_path:
            self.doubleClickedPath.emit(self.original_path)

        # Si YA estamos en el visor (pantalla completa), el doble clic resetea el zoom
        if not self.is_thumbnail_view:
            self.fitToWindow()

        super().mouseDoubleClickEvent(event)

    def _clamp_view_offset(self):
        """Asegura que no 'nos salgamos' de la foto al arrastrar."""
        if self._original_pixmap.isNull() or self._current_scale == 0:
            return

        # Ancho y alto de la "ventana" proyectada sobre la imagen original
        viewport_width = self.width() / self._current_scale
        viewport_height = self.height() / self._current_scale

        img_width = self._original_pixmap.width()
        img_height = self._original_pixmap.height()

        # EJE X
        if img_width <= viewport_width:
            # Si la imagen cabe entera, centramos el offset (o lo dejamos a 0)
            # En realidad, si cabe entera, el paintEvent se encarga de centrar el target.
            # Aquí solo nos aseguramos de no tener offsets locos.
            self._view_offset.setX(0)
        else:
            # Si la imagen es más grande, permitimos movernos hasta el borde
            max_x = img_width - viewport_width
            # Clamp: limitamos entre 0 y el máximo posible
            new_x = max(0.0, min(self._view_offset.x(), max_x))
            self._view_offset.setX(new_x)

        # EJE Y (Misma lógica)
        if img_height <= viewport_height:
            self._view_offset.setY(0)
        else:
            max_y = img_height - viewport_height
            new_y = max(0.0, min(self._view_offset.y(), max_y))
            self._view_offset.setY(new_y)

    def paintEvent(self, event: QPaintEvent):
        if self.is_thumbnail_view:
            super().paintEvent(event)
            return

        if self._original_pixmap.isNull():
            return

        painter = QPainter(self)
        # Usamos transformación bilineal/suave para que no se pixele al hacer zoom
        painter.setRenderHint(QPainter.SmoothPixmapTransform)
        painter.setRenderHint(QPainter.Antialiasing)

        # Dimensiones de la imagen escalada
        scaled_w = self._original_pixmap.width() * self._current_scale
        scaled_h = self._original_pixmap.height() * self._current_scale

        # 1. Calcular TARGET (Dónde pintamos en la pantalla)
        # Si la imagen es pequeña, la centramos. Si es grande, ocupamos toda la pantalla.
        target_x = (self.width() - scaled_w) / 2.0 if scaled_w < self.width() else 0.0
        target_y = (self.height() - scaled_h) / 2.0 if scaled_h < self.height() else 0.0

        # El rectángulo destino es el mínimo entre el tamaño escalado y el tamaño del widget
        target_w = min(scaled_w, float(self.width()))
        target_h = min(scaled_h, float(self.height()))

        target_rect = QRectF(target_x, target_y, target_w, target_h)

        # 2. Calcular SOURCE (Qué trozo de la imagen original cogemos)
        src_x = self._view_offset.x()
        src_y = self._view_offset.y()

        # El ancho/alto origen es el ancho/alto destino "des-escalado"
        src_w = target_w / self._current_scale
        src_h = target_h / self._current_scale

        source_rect = QRectF(src_x, src_y, src_w, src_h)

        # 3. INTERSECCIÓN DE SEGURIDAD (Evita errores de redondeo en los bordes)
        # Nos aseguramos de que no pedimos píxeles fuera de la imagen original
        img_rect = QRectF(self._original_pixmap.rect())
        source_rect = source_rect.intersected(img_rect)

        painter.drawPixmap(target_rect, self._original_pixmap, source_rect)
        painter.end()

    def resizeEvent(self, event):
        # Si estamos en el visor grande
        if not self.is_thumbnail_view:
            # Si la imagen es muy pequeña (acaba de arrancar), forzamos el ajuste
            if self.width() < 100 or self._current_scale == 1.0:
                self.fitToWindow()
            else:
                self._clamp_view_offset()
                self.update()
        super().resizeEvent(event)

    def _open_preview(self):
        # Importación local para evitar ciclos si ImagePreviewDialog está abajo
        # (Aunque en este orden ya no hace falta, es buena práctica)
        if ImagePreviewDialog.is_showing:
            return
        if not self.original_path:
            return
        full_pixmap = QPixmap(self.original_path)
        if full_pixmap.isNull():
            return
        preview_dialog = ImagePreviewDialog(full_pixmap, self)
        preview_dialog.show_with_animation()

# =================================================================
# CLASE: PreviewListWidget (Limpia)
# =================================================================
class PreviewListWidget(QListWidget):
    """
    QListWidget que auto-ajusta su altura basándose en el contenido real.
    """
    previewRequested = Signal(object)

    def __init__(self, parent=None):
        super().__init__(parent)
        self.setUniformItemSizes(False) # Clave para que la selección se ajuste
        self.setResizeMode(QListWidget.Adjust)
        self.setViewMode(QListWidget.IconMode)

    def mouseDoubleClickEvent(self, event):
        if event.button() == Qt.LeftButton:
            item = self.itemAt(event.position().toPoint())
            if item:
                data = item.data(Qt.UserRole)
                if data:
                    self.previewRequested.emit(data)
                    event.accept()
                    return
        super().mouseDoubleClickEvent(event)

    def keyPressEvent(self, event: QKeyEvent):
        if event.key() == Qt.Key_Escape:
            from PySide6.QtWidgets import QApplication
            for widget in QApplication.allWidgets():
                if widget.__class__.__name__ == "ImagePreviewDialog" and widget.isVisible():
                    if hasattr(widget, 'close_with_animation'):
                        widget.close_with_animation()
                    else:
                        widget.close()
                    event.accept()
                    return
        super().keyPressEvent(event)

    def mousePressEvent(self, event):
        # Selección con Shift
        if event.button() == Qt.LeftButton and (event.modifiers() & Qt.ShiftModifier):
            item_clicked = self.itemAt(event.position().toPoint())
            current_anchor = self.currentItem()
            if item_clicked and current_anchor:
                start_row = self.row(current_anchor)
                end_row = self.row(item_clicked)
                low = min(start_row, end_row)
                high = max(start_row, end_row)
                if not (event.modifiers() & Qt.ControlModifier):
                    self.clearSelection()
                for i in range(low, high + 1):
                    self.item(i).setSelected(True)
                self.setCurrentItem(item_clicked)
                return
        super().mousePressEvent(event)

    def resizeEvent(self, event):
        """Al redimensionar la ventana, recalculamos la altura."""
        super().resizeEvent(event)
        self.adjust_height_to_content()

    def adjust_height_to_content(self):
        """Calcula la altura exacta basándose en la posición del último ítem."""
        count = self.count()
        if count == 0: return

        # Forzar el cálculo de posición de los ítems
        self.doItemsLayout()

        # Obtener el rectángulo visual del ÚLTIMO ítem
        last_item_rect = self.visualItemRect(self.item(count - 1))

        if last_item_rect.isValid():
            # La altura necesaria es el fondo del último ítem + margen
            new_height = last_item_rect.bottom() + self.spacing() + 10

            # Solo aplicamos si hay cambio para evitar bucles
            if self.height() != new_height and new_height > 0:
                self.setFixedHeight(new_height)

# =================================================================
# CLASE PARA VISTA PREVIA CON ZOOM (ImagePreviewDialog)
# =================================================================
class ImagePreviewDialog(QDialog):
    is_showing = False
    def __init__(self, pixmap: QPixmap, parent=None):
        super().__init__(parent)
        ImagePreviewDialog.is_showing = True

        # Identificador para que el Label sepa que es un visor
        self.setProperty("is_lightbox", True)

        # Estilo Pantalla Completa y Fondo Transparente
        self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)
        self.setAttribute(Qt.WA_DeleteOnClose)
        self.setAttribute(Qt.WA_TranslucentBackground)
        self.setStyleSheet("background-color: rgba(0, 0, 0, 230);") # Fondo oscuro

        self._pixmap = pixmap

        self.label = ZoomableClickableLabel(parent=self)
        self.label.is_thumbnail_view = False
        self.label.setStyleSheet("background-color: transparent;")

        layout = QVBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.addWidget(self.label)

        self.animation = QPropertyAnimation(self, b"geometry")

    def show_with_animation(self):
        screen = QApplication.screenAt(QCursor.pos())
        if not screen:
            screen = QApplication.primaryScreen()
        screen_geom = screen.availableGeometry()

        self.setGeometry(screen_geom)
        self.label.setOriginalPixmap(self._pixmap)

        # Animación de apertura
        start_rect = QRect(screen_geom.center().x(), screen_geom.center().y(), 0, 0)
        end_rect = screen_geom

        self.animation.setDuration(200)
        self.animation.setStartValue(start_rect)
        self.animation.setEndValue(end_rect)
        self.animation.setEasingCurve(QEasingCurve.OutQuad)
        self.animation.start()

        self.show()

    def close_with_animation(self):
        end_pos = QCursor.pos()
        end_geom = QRect(end_pos.x(), end_pos.y(), 1, 1)
        start_geom = self.geometry()

        self.animation.setDuration(200)
        self.animation.setStartValue(start_geom)
        self.animation.setEndValue(end_geom)
        self.animation.setEasingCurve(QEasingCurve.InQuad)
        self.animation.finished.connect(self._handle_close_animation_finished)
        self.animation.start()

    def _handle_close_animation_finished(self):
        ImagePreviewDialog.is_showing = False
        self.accept()

    def keyPressEvent(self, event: QKeyEvent):
        if event.key() == Qt.Key_Escape:
            self.close_with_animation()
        else:
            super().keyPressEvent(event)

    def resizeEvent(self, event):
        if self.label._current_scale == 1.0:
            self.label.fitToWindow()
        super().resizeEvent(event)

    def changeEvent(self, event):
        """Detecta si la ventana pierde el foco (clic fuera de la app)."""
        if event.type() == QEvent.ActivationChange:
            # Si la ventana deja de ser la activa, cerramos
            if not self.isActiveWindow():
                self.close_with_animation()
        super().changeEvent(event)

    def mousePressEvent(self, event):
        """
        Este evento se activa si el usuario hace clic en el fondo (zona negra),
        porque ZoomableClickableLabel habrá ignorado el evento.
        """
        if event.button() == Qt.LeftButton:
            self.close_with_animation()

# -----------------------------------------------------------------
# CLASE MODIFICADA: PhotoDetailDialog (¡CON SOPORTE RAW!)
# -----------------------------------------------------------------
class PhotoDetailDialog(QDialog):
    metadata_changed = Signal(str, str, str)

    def _setup_ui(self):
        main_layout = QVBoxLayout(self)
        self.main_splitter = QSplitter(Qt.Horizontal)
        main_layout.addWidget(self.main_splitter)

        # Panel Izquierdo: Imagen
        self.image_label = ZoomableClickableLabel(self.original_path, self)
        self.image_label.is_thumbnail_view = False
        self.main_splitter.addWidget(self.image_label)

        # Panel Derecho: Solo fechas (SIN EXIF)
        right_panel_widget = QWidget()
        right_panel_layout = QVBoxLayout(right_panel_widget)
        right_panel_widget.setMinimumWidth(250)
        right_panel_widget.setMaximumWidth(350)

        date_group = QGroupBox("Editar Fecha")
        date_layout = QGridLayout(date_group)

        date_layout.addWidget(QLabel("Año:"), 0, 0)
        self.year_edit = QLineEdit()
        self.year_edit.setPlaceholderText("Ej: 2024")
        date_layout.addWidget(self.year_edit, 0, 1)

        date_layout.addWidget(QLabel("Mes:"), 1, 0)
        self.month_combo = QComboBox()
        self.month_combo.addItem("Mes Desconocido", "00")
        for i in range(1, 13):
            month_str = str(i).zfill(2)
            try:
                month_name = datetime.datetime.strptime(month_str, "%m").strftime("%B").capitalize()
            except ValueError:
                month_name = str(i)
            self.month_combo.addItem(month_name, month_str)
        date_layout.addWidget(self.month_combo, 1, 1)

        right_panel_layout.addWidget(date_group)
        right_panel_layout.addStretch(1) # Relleno para empujar hacia arriba

        self.main_splitter.addWidget(right_panel_widget)

        # Botones
        self.button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Save | QDialogButtonBox.StandardButton.Cancel)
        self.button_box.accepted.connect(self._save_metadata)
        self.button_box.rejected.connect(self.reject)
        main_layout.addWidget(self.button_box)

        # Ajuste de tamaños (más espacio para la foto)
        self.main_splitter.setSizes([800, 250])

    def __init__(self, original_path, db_manager: VisageVaultDB, parent=None):
        super().__init__(parent)
        self.original_path = original_path
        self.db = db_manager
        self.setWindowTitle(Path(original_path).name)
        self.resize(1000, 800)

        self._setup_ui()
        style_sheet = """
            QTreeWidget::item:selected {
                background-color: #3daee9;
                color: white;
            }
            QTreeWidget::item:selected:!active {
                background-color: #3daee9; /* Mismo color aunque pierda el foco */
                color: white;
            }
        """
        self.date_tree_widget.setStyleSheet(style_sheet)
        self.video_date_tree_widget.setStyleSheet(style_sheet)
        self.cloud_date_tree.setStyleSheet(style_sheet) # <--- NUEVO

        self._load_photo()
        self._load_current_date() # Renombrado de _load_metadata

    def _load_photo(self):
        # ... (MANTENER EL CÓDIGO DE CARGA DE IMAGEN/RAW IGUAL QUE ANTES) ...
        # (No copies esto, solo deja el método _load_photo tal cual lo tenías)
        try:
            # Definir extensiones RAW
            RAW_EXTENSIONS = ('.nef', '.cr2', '.cr3', '.crw', '.arw', '.srf', '.orf', '.rw2', '.raf', '.pef', '.dng', '.raw')
            file_suffix = Path(self.original_path).suffix.lower()
            pixmap = QPixmap()

            if file_suffix in RAW_EXTENSIONS:
                with rawpy.imread(self.original_path) as raw:
                    rgb_array = raw.postprocess()
                height, width, channel = rgb_array.shape
                bytes_per_line = 3 * width
                q_image = QImage(rgb_array.data, width, height, bytes_per_line, QImage.Format.Format_RGB888).copy()
                pixmap = QPixmap.fromImage(q_image)
            else:
                pixmap = QPixmap(self.original_path)

            self.image_label.setOriginalPixmap(pixmap)
        except Exception as e:
            self.image_label.setText(f"Error: {e}")

    def _load_current_date(self):
        """Carga solo la fecha actual de la BD o del archivo."""
        current_year, current_month = self.db.get_photo_date(self.original_path)

        # Si no está en BD...
        if current_year is None or current_month is None:
            # 1. Intentar por nombre primero
            current_year, current_month = parse_date_from_filename(self.original_path)

            # 2. Si falla, usar metadatos
            if not current_year:
                current_year, current_month = metadata_reader.get_photo_date(self.original_path)

        self.year_edit.setText(current_year or "Sin Fecha")
        month_index = self.month_combo.findData(current_month or "00")
        self.month_combo.setCurrentIndex(month_index if month_index != -1 else 0)

    def _save_metadata(self):
        # ... (MANTENER IGUAL QUE ANTES) ...
        # Solo cambia la BD, lo cual es correcto según tus instrucciones.
        try:
            new_year_str = self.year_edit.text()
            new_month_str = self.month_combo.currentData()

            # Validación simple
            if not (new_year_str == "Sin Fecha" or (len(new_year_str) == 4 and new_year_str.isdigit())):
                from PySide6.QtWidgets import QMessageBox
                QMessageBox.warning(self, "Datos Inválidos", "Año inválido.")
                return

            # Guardar en BD
            self.db.update_photo_date(self.original_path, new_year_str, new_month_str)

            # Notificar cambio
            self.metadata_changed.emit(self.original_path, new_year_str, new_month_str)
            self.accept()
        except Exception as e:
            print(f"Error al guardar: {e}")

# =================================================================
# CLASE: DIÁLOGO DE ETIQUETADO DE GRUPOS (CLUSTERS) (Sin cambios)
# =================================================================
class FaceClusterDialog(QDialog):
    SkipRole = QDialog.Accepted + 1
    DeleteRole = QDialog.Accepted + 2
    def __init__(self, db: VisageVaultDB, threadpool: QThreadPool,
                 face_ids: list, parent=None):
        super().__init__(parent)
        self.db = db
        self.threadpool = threadpool
        self.face_ids = face_ids
        self.local_face_signals = FaceLoaderSignals()
        self.local_face_signals.face_loaded.connect(self._on_dialog_face_loaded)
        self.setWindowTitle(f"Agrupar {len(self.face_ids)} Caras")
        self.setMinimumSize(600, 400)
        self.person_id_to_save = None
        self._setup_ui()
        self._load_people_combo()
        self._load_faces_async()
    def _setup_ui(self):
        main_layout = QVBoxLayout(self)
        face_scroll_area = QScrollArea()
        face_scroll_area.setWidgetResizable(True)
        face_widget = QWidget()
        self.face_grid_layout = QGridLayout(face_widget)
        self.face_grid_layout.setSpacing(10)
        face_scroll_area.setWidget(face_widget)
        main_layout.addWidget(face_scroll_area, 1)
        assign_group = QGroupBox("Asignar Persona")
        assign_layout = QGridLayout(assign_group)
        assign_layout.addWidget(QLabel("Persona Existente:"), 0, 0)
        self.people_combo = QComboBox()
        self.people_combo.currentIndexChanged.connect(self._on_combo_changed)
        assign_layout.addWidget(self.people_combo, 0, 1)
        assign_layout.addWidget(QLabel("O Nueva Persona:"), 1, 0)
        self.new_person_edit = QLineEdit()
        self.new_person_edit.setPlaceholderText("Ej: Ana García")
        self.new_person_edit.textChanged.connect(self._on_text_changed)
        assign_layout.addWidget(self.new_person_edit, 1, 1)
        main_layout.addWidget(assign_group)
        self.button_box = QDialogButtonBox(
            QDialogButtonBox.StandardButton.Save | QDialogButtonBox.StandardButton.Cancel
        )
        self.skip_button = self.button_box.addButton("Siguiente", QDialogButtonBox.ButtonRole.ActionRole)
        self.skip_button.clicked.connect(self._skip)
        self.delete_button = self.button_box.addButton("Eliminar caras", QDialogButtonBox.ButtonRole.DestructiveRole)
        self.delete_button.clicked.connect(self._delete_and_reject)
        self.button_box.accepted.connect(self._save_and_accept)
        self.button_box.rejected.connect(self.reject)
        main_layout.addWidget(self.button_box)
    def _load_people_combo(self):
        self.people_combo.addItem("--- Seleccionar ---", -1)
        people = self.db.get_all_people()
        for person_row in people:
            person_id = person_row['id']
            person_name = person_row['name']
            self.people_combo.addItem(person_name, person_id)
    def _load_faces_async(self):
        num_cols = max(1, (self.width() - 50) // 110)
        for i, face_id in enumerate(self.face_ids):
            face_widget = CircularFaceLabel(QPixmap())
            face_widget.setText("Cargando...")
            face_widget.setProperty("face_id", face_id)
            face_widget.clicked.connect(self._show_face_preview)
            row, col = i // num_cols, i % num_cols
            self.face_grid_layout.addWidget(face_widget, row, col, Qt.AlignTop)
            face_info = self.db.get_face_info(face_id)
            if face_info:
                loader = FaceLoader(
                    self.local_face_signals,
                    face_id,
                    face_info['filepath'],
                    face_info['location']
                )
                self.threadpool.start(loader)
    @Slot()
    def _on_combo_changed(self):
        if self.people_combo.currentIndex() > 0:
            self.new_person_edit.clear()
    @Slot()
    def _on_text_changed(self, text):
        if text:
            self.people_combo.setCurrentIndex(0)
    @Slot()
    def _save_and_accept(self):
        try:
            new_name = self.new_person_edit.text().strip()
            selected_id = self.people_combo.currentData()
            if new_name:
                person_id = self.db.add_person(new_name)
                if person_id == -1:
                    existing = self.db.get_person_by_name(new_name)
                    person_id = existing['id']
                self.person_id_to_save = person_id
            elif selected_id != -1:
                self.person_id_to_save = selected_id
            else:
                from PySide6.QtWidgets import QMessageBox
                QMessageBox.warning(self, "Acción Requerida",
                                    "Por favor, selecciona una persona existente o escribe un nombre nuevo.")
                return
            if self.person_id_to_save:
                for face_id in self.face_ids:
                    self.db.restore_face(face_id)
                    self.db.link_face_to_person(face_id, self.person_id_to_save)
                self.accept()
        except Exception as e:
            print(f"Error al guardar el cluster: {e}")
    @Slot(int, QPixmap, str)
    def _on_dialog_face_loaded(self, face_id: int, pixmap: QPixmap, photo_path: str):
        for i in range(self.face_grid_layout.count()):
            widget = self.face_grid_layout.itemAt(i).widget()
            if widget and hasattr(widget, 'property') and widget.property("face_id") == face_id:
                widget.setPixmap(pixmap)
                widget.setText("")
                widget.setProperty("photo_path", photo_path)
                break
    @Slot()
    @Slot()
    def _show_face_preview(self):
        sender_widget = self.sender()
        if not sender_widget:
            return

        photo_path = sender_widget.property("photo_path")
        if not photo_path:
            print("Por favor, espera a que la cara termine de cargar.")
            return

        # --- SOPORTE RAW PARA VISTA PREVIA ---
        RAW_EXTENSIONS = ('.nef', '.cr2', '.cr3', '.crw', '.arw', '.srf', '.orf', '.rw2', '.raf', '.pef', '.dng', '.raw')
        file_suffix = Path(photo_path).suffix.lower()

        full_pixmap = QPixmap()

        try:
            if file_suffix in RAW_EXTENSIONS:
                # Procesar con rawpy
                with rawpy.imread(photo_path) as raw:
                    rgb_array = raw.postprocess()

                height, width, channel = rgb_array.shape
                bytes_per_line = 3 * width
                q_image = QImage(rgb_array.data, width, height, bytes_per_line, QImage.Format.Format_RGB888).copy()
                full_pixmap = QPixmap.fromImage(q_image)
            else:
                # Procesar estándar
                full_pixmap = QPixmap(photo_path)

            if full_pixmap.isNull():
                print(f"Error: No se pudo cargar la imagen completa de {photo_path}")
                return

            preview_dialog = ImagePreviewDialog(full_pixmap, self)
            preview_dialog.setModal(True)
            preview_dialog.show_with_animation()

        except Exception as e:
            print(f"Error al mostrar preview de cara: {e}")

    @Slot()
    def _skip(self):
        self.done(self.SkipRole)
    @Slot()
    def _delete_and_reject(self):
        if self.face_ids:
            for face_id in self.face_ids:
                self.db.soft_delete_face(face_id)
        self.done(self.DeleteRole)

# =================================================================
# CLASE: DIÁLOGO PARA CAMBIO RÁPIDO DE FECHA
# =================================================================
class DateChangeDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Cambiar Fecha")
        self.setFixedSize(300, 150)

        layout = QVBoxLayout(self)

        # Formulario
        form_layout = QGridLayout()

        # Año
        form_layout.addWidget(QLabel("Año (AAAA):"), 0, 0)
        self.year_edit = QLineEdit()
        self.year_edit.setPlaceholderText("Ej: 2024")
        self.year_edit.setMaxLength(4)
        form_layout.addWidget(self.year_edit, 0, 1)

        # Mes
        form_layout.addWidget(QLabel("Mes:"), 1, 0)
        self.month_combo = QComboBox()
        # Añadir meses
        self.month_combo.addItem("Enero", "01")
        self.month_combo.addItem("Febrero", "02")
        self.month_combo.addItem("Marzo", "03")
        self.month_combo.addItem("Abril", "04")
        self.month_combo.addItem("Mayo", "05")
        self.month_combo.addItem("Junio", "06")
        self.month_combo.addItem("Julio", "07")
        self.month_combo.addItem("Agosto", "08")
        self.month_combo.addItem("Septiembre", "09")
        self.month_combo.addItem("Octubre", "10")
        self.month_combo.addItem("Noviembre", "11")
        self.month_combo.addItem("Diciembre", "12")
        self.month_combo.addItem("Desconocido", "00")

        # Seleccionar el mes actual por defecto
        current_month_idx = datetime.datetime.now().month - 1
        self.month_combo.setCurrentIndex(current_month_idx)

        form_layout.addWidget(self.month_combo, 1, 1)
        layout.addLayout(form_layout)

        # Botones
        button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        button_box.accepted.connect(self._validate_and_accept)
        button_box.rejected.connect(self.reject)
        layout.addWidget(button_box)

    def _validate_and_accept(self):
        year = self.year_edit.text().strip()

        # Validación: Debe ser 4 dígitos numéricos
        if not year.isdigit() or len(year) != 4:
            from PySide6.QtWidgets import QMessageBox # Asegurar import
            QMessageBox.warning(self, "Año incorrecto", "Por favor, escribe un año válido de 4 cifras (ej: 2025).")
            return

        self.accept()

    def get_data(self):
        return self.year_edit.text().strip(), self.month_combo.currentData()

# =================================================================
# CLASE TRABAJADORA DEL ESCANEO DE FOTOS (Sin cambios)
# =================================================================
class PhotoFinderWorker(QObject):
    finished = Signal(dict)
    progress = Signal(str)

    # Recibimos db_path (texto) en lugar de db_manager (objeto)
    def __init__(self, directory_path: str, db_path: str):
        super().__init__()
        self.directory_path = directory_path
        self.db_path = db_path
        self.is_running = True

    @Slot()
    def run(self):
        # Abrimos nuestra propia conexión segura
        local_db = VisageVaultDB(os.path.basename(self.db_path), is_worker=True)
        # Forzamos que use la ruta correcta si no coincide con el default
        local_db.db_path = self.db_path
        local_db.conn = sqlite3.connect(self.db_path, check_same_thread=False)
        local_db.conn.row_factory = sqlite3.Row

        photos_by_year_month = {}
        try:
            self.progress.emit("Cargando fechas de fotos conocidas desde la BD...")
            db_dates = local_db.load_all_photo_dates()

            self.progress.emit("Escaneando archivos de FOTOS en el directorio...")
            photo_paths_on_disk = find_photos(self.directory_path)
            photo_paths_on_disk_set = set(photo_paths_on_disk)

            photos_to_upsert_in_db = []

            for path in photo_paths_on_disk:
                if not self.is_running:
                    break
                if path in db_dates:
                    year, month = db_dates[path]
                else:
                    self.progress.emit(f"Procesando nueva foto: {Path(path).name}")
                    year, month = parse_date_from_filename(path)

                    # Si no se encontró fecha en el nombre, usamos metadatos internos (EXIF)
                    if not year:
                        year, month = get_photo_date(path)
                    # ---------------------------------------------------

                    photos_to_upsert_in_db.append((path, year, month))

                if year not in photos_by_year_month:
                    photos_by_year_month[year] = {}
                if month not in photos_by_year_month[year]:
                    photos_by_year_month[year][month] = []
                photos_by_year_month[year][month].append(path)

            self.progress.emit("Buscando fotos eliminadas...")
            db_paths_set = set(db_dates.keys())
            paths_to_delete = list(db_paths_set - photo_paths_on_disk_set)

            if paths_to_delete:
                self.progress.emit(f"Eliminando {len(paths_to_delete)} fotos de la BD...")
                local_db.bulk_delete_photos(paths_to_delete)

            if photos_to_upsert_in_db:
                self.progress.emit(f"Guardando {len(photos_to_upsert_in_db)} fotos nuevas en la BD...")
                local_db.bulk_upsert_photos(photos_to_upsert_in_db)

            self.progress.emit(f"Escaneo de fotos finalizado. Encontradas {len(photo_paths_on_disk)} fotos.")

        except Exception as e:
            print(f"Error crítico en el hilo PhotoFinderWorker: {e}")
            self.progress.emit(f"Error en escaneo de fotos: {e}")
        finally:
            # Cerramos conexión
            local_db.conn.close()
            self.finished.emit(photos_by_year_month)

# =================================================================
# CLASE TRABAJADORA DEL ESCANEO DE VÍDEOS (Sin cambios)
# =================================================================
class VideoFinderWorker(QObject):
    finished = Signal(dict)
    progress = Signal(str)

    def __init__(self, directory_path: str, db_path: str):
        super().__init__()
        self.directory_path = directory_path
        self.db_path = db_path
        self.is_running = True

    @Slot()
    def run(self):
        local_db = VisageVaultDB(os.path.basename(self.db_path), is_worker=True)
        local_db.db_path = self.db_path
        local_db.conn = sqlite3.connect(self.db_path, check_same_thread=False)
        local_db.conn.row_factory = sqlite3.Row

        videos_by_year_month = {}
        try:
            self.progress.emit("Cargando fechas de vídeos conocidas desde la BD...")
            db_dates = local_db.load_all_video_dates()

            self.progress.emit("Escaneando archivos de VÍDEOS en el directorio...")
            video_paths_on_disk = find_videos(self.directory_path)
            video_paths_on_disk_set = set(video_paths_on_disk)

            videos_to_upsert_in_db = []

            for path in video_paths_on_disk:
                if not self.is_running:
                    break
                if path in db_dates:
                    year, month = db_dates[path]
                else:
                    self.progress.emit(f"Procesando nuevo vídeo: {Path(path).name}")
                    year, month = parse_date_from_filename(path)

                    # Si no hay fecha en nombre, buscar metadatos internos
                    if not year:
                        year, month = get_video_date(path)

                if year not in videos_by_year_month:
                    videos_by_year_month[year] = {}
                if month not in videos_by_year_month[year]:
                    videos_by_year_month[year][month] = []
                videos_by_year_month[year][month].append(path)

            self.progress.emit("Buscando vídeos eliminados...")
            db_paths_set = set(db_dates.keys())
            paths_to_delete = list(db_paths_set - video_paths_on_disk_set)

            if paths_to_delete:
                self.progress.emit(f"Eliminando {len(paths_to_delete)} vídeos de la BD...")
                local_db.bulk_delete_videos(paths_to_delete)

            if videos_to_upsert_in_db:
                self.progress.emit(f"Guardando {len(videos_to_upsert_in_db)} vídeos nuevos en la BD...")
                local_db.bulk_upsert_videos(videos_to_upsert_in_db)

            self.progress.emit(f"Escaneo de vídeos finalizado. Encontrados {len(video_paths_on_disk)} vídeos.")

        except Exception as e:
            print(f"Error crítico en el hilo VideoFinderWorker: {e}")
            self.progress.emit(f"Error en escaneo de vídeos: {e}")
        finally:
            local_db.conn.close()
            self.finished.emit(videos_by_year_month)

# =================================================================
# CLASE TRABAJADORA DEL ESCANEO DE CARAS (CIERRE SEGURO)
# =================================================================
class FaceScanSignals(QObject):
    scan_progress = Signal(str)
    scan_percentage = Signal(int)
    face_found = Signal(int, str, str)
    scan_finished = Signal()

class FaceScanWorker(QObject):
    def __init__(self, db_path: str):
        super().__init__()
        self.db_path = db_path
        self.signals = FaceScanSignals()
        self.is_running = True
        self.executor = None # Referencia para poder matarlo desde fuera

    def stop(self):
        """Fuerza la detención inmediata de los hilos."""
        self.is_running = False
        if self.executor:
            # wait=False: No esperar a que terminen las tareas pendientes
            # cancel_futures=True: Cancelar las que están en cola (Python 3.9+)
            print("🛑 Forzando apagado del motor de IA...")
            self.executor.shutdown(wait=False, cancel_futures=True)

    @Slot()
    def run(self):
        local_db = VisageVaultDB(os.path.basename(self.db_path), is_worker=True)
        local_db.db_path = self.db_path
        local_db.conn = sqlite3.connect(self.db_path, check_same_thread=False)
        local_db.conn.row_factory = sqlite3.Row
        local_db.conn.execute("PRAGMA journal_mode=WAL;")

        try:
            self.signals.scan_progress.emit("Buscando fotos sin escanear...")
            unscanned_photos = local_db.get_unscanned_photos()
            total = len(unscanned_photos)

            if total == 0:
                self.signals.scan_progress.emit("No hay fotos nuevas.")
                self.signals.scan_percentage.emit(100)
                self.signals.scan_finished.emit()
                return

            self.signals.scan_progress.emit(f"Escaneando {total} fotos...")

            # WARMUP
            try:
                import face_recognition
                dummy = np.zeros((50, 50, 3), dtype=np.uint8)
                face_recognition.face_locations(dummy, model="hog")
            except Exception: pass

            max_workers = 1 # max_workers = min(4, os.cpu_count() or 2)
            processed_count = 0

            # Guardamos el executor en self para poder matarlo en stop()
            self.executor = ThreadPoolExecutor(max_workers=max_workers)

            with self.executor:
                future_to_photo = {}
                for row in unscanned_photos:
                    if not self.is_running: break
                    p_id = row['id']
                    p_path = row['filepath']

                    future = self.executor.submit(self._process_single_image, p_id, p_path)
                    future_to_photo[future] = (p_id, p_path)

                for future in as_completed(future_to_photo):
                    if not self.is_running:
                        # Si nos mandan parar, rompemos el bucle
                        break

                    photo_id, photo_path = future_to_photo[future]
                    try:
                        # Timeout pequeño para no bloquear eternamente si se cierra la app
                        result_data = future.result(timeout=0.1)

                        if result_data:
                            for (encoding_blob, location_str) in result_data:
                                face_db_id = local_db.add_face(photo_id, encoding_blob, location_str)
                                self.signals.face_found.emit(face_db_id, photo_path, location_str)

                        local_db.mark_photo_as_scanned(photo_id)

                    except TimeoutError:
                        # Si tarda mucho y estamos cerrando, ignorar
                        pass
                    except Exception as e:
                        # print(f"Error procesando {photo_path}: {e}")
                        local_db.mark_photo_as_scanned(photo_id)

                    processed_count += 1
                    if processed_count % 5 == 0:
                        percentage = int((processed_count / total) * 100)
                        self.signals.scan_percentage.emit(percentage)
                        self.signals.scan_progress.emit(f"Analizando caras ({processed_count}/{total})...")

            self.signals.scan_finished.emit()

        except Exception as e:
            # print(f"Worker interrumpido o error: {e}")
            self.signals.scan_finished.emit()
        finally:
            # Asegurar limpieza final
            if self.executor:
                self.executor.shutdown(wait=False)
            try: local_db.conn.close()
            except: pass

    def _process_single_image(self, photo_id, photo_path):
        # ... (Mantén este método IGUAL que en la versión PIL anterior) ...
        # (Copia el método _process_single_image de mi respuesta anterior)
        # Extensiones RAW
        RAW_EXTENSIONS = ('.nef', '.cr2', '.cr3', '.crw', '.arw', '.srf', '.orf', '.rw2', '.raf', '.pef', '.dng', '.raw')

        try:
            image = None
            file_suffix = Path(photo_path).suffix.lower()

            if file_suffix in RAW_EXTENSIONS:
                try:
                    with rawpy.imread(photo_path) as raw:
                        image = raw.postprocess()
                except Exception:
                    return None
            else:
                image = face_recognition.load_image_file(photo_path)

            if image is None: return None

            h, w = image.shape[:2]
            max_width = 1000
            scale_ratio = 1.0

            if w > max_width:
                scale_ratio = max_width / float(w)
                new_h = int(h * scale_ratio)
                pil_image = Image.fromarray(image)
                pil_image = pil_image.resize((max_width, new_h), Image.Resampling.LANCZOS)
                image = np.array(pil_image)

            locations = face_recognition.face_locations(image, model="hog")
            faces_found = []

            if locations:
                encodings = face_recognition.face_encodings(image, locations)
                for loc, enc in zip(locations, encodings):
                    if scale_ratio != 1.0:
                        top, right, bottom, left = loc
                        top = int(top / scale_ratio)
                        right = int(right / scale_ratio)
                        bottom = int(bottom / scale_ratio)
                        left = int(left / scale_ratio)
                        loc = (top, right, bottom, left)

                    faces_found.append((pickle.dumps(enc), str(loc)))
            return faces_found

        except Exception:
            return None

# =================================================================
# CLASE: DIÁLOGO DE AYUDA Y ACERCA DE
# =================================================================
class HelpDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Ayuda y Acerca de VisageVault")
        self.setFixedSize(500, 600)

        layout = QVBoxLayout(self)

        # 1. Logo
        logo_label = QLabel()
        logo_label.setAlignment(Qt.AlignCenter)
        # Usamos resource_path para que funcione en el .exe compilado
        logo_path = resource_path("visagevault.png")
        if os.path.exists(logo_path):
            pixmap = QPixmap(logo_path)
            logo_label.setPixmap(pixmap.scaled(128, 128, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        layout.addWidget(logo_label)

        # 2. Título y Versión
        title_label = QLabel("<h2>VisageVault v1.4</h2>")
        title_label.setAlignment(Qt.AlignCenter)
        layout.addWidget(title_label)

        # 3. Texto de Ayuda (HTML)
        help_text = """
        <style>
            p { margin-bottom: 10px; line-height: 1.4; }
            a { color: #3daee9; text-decoration: none; font-weight: bold; }
        </style>

        <h3>📖 Guía Rápida</h3>
        <p><b>📷 Fotos / 🎥 Vídeos:</b> Navega por tus recuerdos organizados por fecha.
        Haz <b>doble clic</b> para ver en detalle. Usa <b>Rueda</b> para zoom.</p>

        <p><b>👥 Personas:</b> La IA agrupa caras automáticamente.
        Entra en esta pestaña para etiquetar a tus amigos y familiares.</p>

        <p><b>🖱️ Acciones:</b> Haz <b>Clic Derecho</b> en una foto o vídeo para:
        <ul>
            <li>Cambiar su fecha (y actualizar el archivo).</li>
            <li>Ocultarlo de la vista principal.</li>
            <li>Eliminarlo permanentemente.</li>
        </ul>
        </p>

        <hr>

        <h3>📬 Contacto y Soporte</h3>
        <p>Desarrollado por <b>Daniel Serrano Armenta</b>.</p>

        <p>🐙 <b>GitHub:</b><br>
        <a href="https://github.com/AnabasaSoft/VisageVault">github.com/AnabasaSoft/VisageVault</a></p>

        <p>📧 <b>Email:</b><br>
        <a href="mailto:anabasasoft@gmail.com">anabasasoft@gmail.com</a></p>
        """

        info_label = QLabel(help_text)
        info_label.setWordWrap(True)
        info_label.setOpenExternalLinks(True) # ¡Importante para que funcionen los links!
        info_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
        info_label.setTextInteractionFlags(Qt.TextBrowserInteraction)

        # Área de scroll por si el texto es largo
        scroll = QScrollArea()
        scroll.setWidget(info_label)
        scroll.setWidgetResizable(True)
        scroll.setFrameShape(QFrame.NoFrame)
        layout.addWidget(scroll)

        # 4. Botón Cerrar
        btn_box = QDialogButtonBox(QDialogButtonBox.Close)
        btn_box.rejected.connect(self.accept)
        layout.addWidget(btn_box)

# =================================================================
# CLASE: VIGILANTE DEL SISTEMA DE ARCHIVOS (AUTO-REFRESH)
# =================================================================
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class PhotoDirWatcher(QObject):
    """
    Vigila cambios en el directorio de fotos y emite señales para refrescar la UI.
    """
    directory_changed = Signal()

    def __init__(self, path_to_watch):
        super().__init__()
        self.path_to_watch = path_to_watch
        self.observer = Observer()
        self.handler = self.ChangeHandler(self.directory_changed)

    def start(self):
        if os.path.isdir(self.path_to_watch):
            self.observer.schedule(self.handler, self.path_to_watch, recursive=True)
            self.observer.start()
            # print(f"Vigilando cambios en: {self.path_to_watch}")

    def stop(self):
        if self.observer.is_alive():
            self.observer.stop()
            self.observer.join()

    class ChangeHandler(FileSystemEventHandler):
        def __init__(self, signal):
            self.signal = signal
            self.last_emit_time = 0

        def on_any_event(self, event):
            # Ignorar directorios y archivos temporales o de caché
            if event.is_directory:
                return

            filename = os.path.basename(event.src_path)
            if filename.startswith('.') or "face_cache" in event.src_path:
                return

            # Comprobar extensiones relevantes (Fotos y Vídeos)
            valid_exts = (
                '.jpg', '.jpeg', '.png', '.tiff', '.webp', '.heic', '.nef', '.cr2', '.dng', '.raw', # Fotos
                '.mp4', '.avi', '.mkv', '.mov' # Vídeos
            )
            if not filename.lower().endswith(valid_exts):
                return

            # Debounce: Evitar emitir 100 señales si copias 100 fotos de golpe
            # Emitimos la señal y dejamos que la App gestione el refresco con un Timer
            self.signal.emit()

# =================================================================
# GESTOR DE ENCRIPTACIÓN Y CAJA FUERTE (ACTUALIZADO)
# =================================================================
class CryptoManager:
    """
    Maneja la encriptación XOR usando Numpy para máxima velocidad.
    Procesa archivos grandes (vídeos) en fracciones de segundo.
    """

    SAFE_DIR = Path("visagevault_safe")

    @staticmethod
    def get_key_from_password(password):
        if not password: return b'default_key'
        return hashlib.sha256(password.encode()).digest() # 32 bytes

    @staticmethod
    def process_file(input_path, output_path, password, encrypt=True):
        """Encripta o desencripta de DISCO a DISCO usando Numpy."""
        # Asegurar directorio destino
        if output_path:
            Path(output_path).parent.mkdir(parents=True, exist_ok=True)

        key_bytes = CryptoManager.get_key_from_password(password)

        # Convertir clave a array uint8 una sola vez
        key_arr = np.frombuffer(key_bytes, dtype=np.uint8)

        # Usamos un chunk grande (4MB) para velocidad de disco
        # 4MB es múltiplo de 32 bytes (tamaño clave), así que la alineación es perfecta
        CHUNK_SIZE = 4 * 1024 * 1024

        # Pre-creamos un array de clave gigante para hacer XOR directo con el chunk
        # Esto evita redimensionar la clave en cada vuelta del bucle
        full_key_tile = np.resize(key_arr, CHUNK_SIZE)

        with open(input_path, 'rb') as f_in, open(output_path, 'wb') as f_out:
            while True:
                chunk = f_in.read(CHUNK_SIZE)
                if not chunk: break

                # Convertir chunk a numpy
                chunk_arr = np.frombuffer(chunk, dtype=np.uint8)

                # Obtener la parte correspondiente de la clave (por si es el último chunk más pequeño)
                current_key = full_key_tile[:len(chunk_arr)]

                # --- LA MAGIA: XOR VECTORIZADO (C++ Speed) ---
                encrypted_arr = np.bitwise_xor(chunk_arr, current_key)
                # ---------------------------------------------

                # Escribir a disco
                f_out.write(encrypted_arr.tobytes())

    @staticmethod
    def decrypt_to_bytes(input_path, password):
        """Desencripta a MEMORIA (para previsualización) usando Numpy."""
        if not os.path.exists(input_path): return None

        key_bytes = CryptoManager.get_key_from_password(password)
        key_arr = np.frombuffer(key_bytes, dtype=np.uint8)

        CHUNK_SIZE = 4 * 1024 * 1024
        full_key_tile = np.resize(key_arr, CHUNK_SIZE)

        decrypted_data = bytearray()

        try:
            with open(input_path, 'rb') as f:
                while True:
                    chunk = f.read(CHUNK_SIZE)
                    if not chunk: break

                    chunk_arr = np.frombuffer(chunk, dtype=np.uint8)
                    current_key = full_key_tile[:len(chunk_arr)]

                    decrypted_arr = np.bitwise_xor(chunk_arr, current_key)

                    decrypted_data.extend(decrypted_arr.tobytes())

            return bytes(decrypted_data)
        except Exception as e:
            print(f"Error desencriptando visualización: {e}")
            return None

# =================================================================
# DIÁLOGOS DE SEGURIDAD
# =================================================================
class CreatePasswordDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Crear Contraseña de Caja Fuerte")
        self.resize(300, 150)
        layout = QVBoxLayout(self)

        layout.addWidget(QLabel("Establece una contraseña para proteger tus fotos:"))
        self.pass1 = QLineEdit()
        self.pass1.setEchoMode(QLineEdit.Password)
        self.pass1.setPlaceholderText("Contraseña")
        layout.addWidget(self.pass1)

        self.pass2 = QLineEdit()
        self.pass2.setEchoMode(QLineEdit.Password)
        self.pass2.setPlaceholderText("Repetir Contraseña")
        layout.addWidget(self.pass2)

        btns = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        btns.accepted.connect(self.validate)
        btns.rejected.connect(self.reject)
        layout.addWidget(btns)

        self.password = None

    def validate(self):
        p1 = self.pass1.text()
        p2 = self.pass2.text()
        if not p1:
            QMessageBox.warning(self, "Error", "La contraseña no puede estar vacía.")
            return
        if p1 != p2:
            QMessageBox.warning(self, "Error", "Las contraseñas no coinciden.")
            return
        self.password = p1
        self.accept()

class LoginDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Acceso a Caja Fuerte")
        self.resize(300, 120)
        layout = QVBoxLayout(self)

        layout.addWidget(QLabel("Introduce tu contraseña:"))
        self.pass_edit = QLineEdit()
        self.pass_edit.setEchoMode(QLineEdit.Password)
        layout.addWidget(self.pass_edit)

        btns = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        btns.accepted.connect(self.validate)
        btns.rejected.connect(self.reject)
        layout.addWidget(btns)

        self.password = None

    def validate(self):
        pwd = self.pass_edit.text()
        if config_manager.verify_safe_password(pwd):
            self.password = pwd
            self.accept()
        else:
            QMessageBox.warning(self, "Error", "Contraseña incorrecta.")
            self.pass_edit.clear()

# =================================================================
# NUEVAS CLASES PARA BÚSQUEDA DE DUPLICADOS
# =================================================================

class DuplicateFinderWorker(QObject):
    """
    Busca duplicados visuales usando dHash con PIL.
    Detecta la misma imagen aunque tenga diferente resolución.
    """
    progress = Signal(str)
    finished = Signal(dict)  # { 'hash_string': [ruta1, ruta2], ... }

    def __init__(self, db_path):
        super().__init__()
        self.db_path = db_path
        self.is_running = True

    def _calculate_dhash(self, image_path, hash_size=8):
        """
        Calcula una huella digital visual de la imagen.
        Resistente a cambios de tamaño.
        """
        try:
            # Abrir imagen con PIL
            with Image.open(image_path) as img:
                # 1. Convertir a escala de grises
                img = img.convert("L")

                # 2. Redimensionar a (hash_size + 1) x hash_size (ej: 9x8)
                # Usamos LANCZOS para mejor calidad en la reducción
                try:
                    resample = Image.Resampling.LANCZOS
                except AttributeError:
                    resample = Image.LANCZOS

                img = img.resize((hash_size + 1, hash_size), resample)

                pixels = list(img.getdata())

                # 3. Comparar píxeles adyacentes
                difference = []
                for row in range(hash_size):
                    for col in range(hash_size):
                        pixel_left = pixels[row * (hash_size + 1) + col]
                        pixel_right = pixels[row * (hash_size + 1) + col + 1]
                        difference.append(pixel_left > pixel_right)

                # 4. Convertir a hex
                decimal_value = 0
                for index, value in enumerate(difference):
                    if value:
                        decimal_value += 2**index

                return hex(decimal_value)
        except Exception:
            # Si PIL falla (ej: archivo corrupto o RAW no soportado), lo ignoramos
            return None

    @Slot()
    def run(self):
        # Conexión DB local para el hilo
        local_db = VisageVaultDB(os.path.basename(self.db_path), is_worker=True)
        local_db.db_path = self.db_path
        local_db.conn = sqlite3.connect(self.db_path, check_same_thread=False)
        local_db.conn.row_factory = sqlite3.Row

        try:
            self.progress.emit("Cargando lista de fotos...")
            cursor = local_db.conn.execute("SELECT filepath FROM photos WHERE is_hidden = 0")
            all_photos = [row['filepath'] for row in cursor.fetchall()]

            total = len(all_photos)
            self.progress.emit(f"Analizando {total} fotos visualmente...")

            hashes = {}
            processed = 0

            for path in all_photos:
                if not self.is_running: break
                if not os.path.exists(path): continue

                # Calculamos el hash visual
                dhash = self._calculate_dhash(path)

                if dhash:
                    if dhash not in hashes:
                        hashes[dhash] = []
                    hashes[dhash].append(path)

                processed += 1
                if processed % 20 == 0:
                    self.progress.emit(f"Analizando... ({processed}/{total})")

            # Filtrar solo los que tienen más de 1 archivo (duplicados)
            duplicates = {h: paths for h, paths in hashes.items() if len(paths) > 1}

            self.finished.emit(duplicates)

        except Exception as e:
            print(f"Error en búsqueda duplicados: {e}")
            self.finished.emit({})
        finally:
            local_db.conn.close()


class DuplicateDialog(QDialog):
    """Diálogo para ver y gestionar los duplicados encontrados."""
    def __init__(self, duplicates_dict, db_manager, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Gestor de Fotos Duplicadas")
        self.resize(1000, 700)
        self.duplicates = duplicates_dict
        self.db = db_manager
        self.deleted_paths = set() # Registro de lo borrado

        self._setup_ui()
        self._load_list()

    def _setup_ui(self):
        main_layout = QHBoxLayout(self)

        # IZQUIERDA: Lista de conflictos
        left_panel = QWidget()
        left_layout = QVBoxLayout(left_panel)
        left_layout.addWidget(QLabel("Grupos de Duplicados:"))
        self.list_widget = QListWidget()
        self.list_widget.currentRowChanged.connect(self._on_group_selected)
        left_layout.addWidget(self.list_widget)
        main_layout.addWidget(left_panel, 1)

        # DERECHA: Vista previa
        right_panel = QWidget()
        right_layout = QVBoxLayout(right_panel)

        info = QLabel("Comparativa (Borra la de menor calidad):")
        info.setStyleSheet("font-weight: bold; font-size: 14px; color: #3daee9;")
        right_layout.addWidget(info)

        self.scroll_area = QScrollArea()
        self.scroll_area.setWidgetResizable(True)
        self.preview_container = QWidget()
        self.preview_layout = QHBoxLayout(self.preview_container)
        self.preview_layout.setAlignment(Qt.AlignLeft)
        self.scroll_area.setWidget(self.preview_container)
        right_layout.addWidget(self.scroll_area)

        btn_close = QPushButton("Cerrar")
        btn_close.clicked.connect(self.accept)
        right_layout.addWidget(btn_close, 0, Qt.AlignRight)

        main_layout.addWidget(right_panel, 3)

    def _load_list(self):
        self.list_widget.clear()
        for h, paths in self.duplicates.items():
            # Filtrar si ya borramos alguna
            valid_paths = [p for p in paths if p not in self.deleted_paths and os.path.exists(p)]
            if len(valid_paths) > 1:
                name = Path(valid_paths[0]).name
                item = QListWidgetItem(f"{name} ({len(valid_paths)} copias)")
                item.setData(Qt.UserRole, valid_paths)
                self.list_widget.addItem(item)

    def _on_group_selected(self, row):
        if row < 0: return
        # Limpiar vista previa anterior
        while self.preview_layout.count() > 0:
            item = self.preview_layout.takeAt(0)
            if item.widget(): item.widget().deleteLater()

        item = self.list_widget.item(row)
        paths = item.data(Qt.UserRole)
        valid_paths = [p for p in paths if p not in self.deleted_paths and os.path.exists(p)]

        if len(valid_paths) < 2:
            self.list_widget.takeItem(row) # Ya no es duplicado
            return

        for path in valid_paths:
            self._add_preview_card(path)

    def _add_preview_card(self, path):
        card = QFrame()
        card.setFrameShape(QFrame.StyledPanel)
        card.setStyleSheet("background-color: #2b2b2b; border-radius: 8px; margin: 5px;")
        layout = QVBoxLayout(card)

        # Imagen
        lbl = ZoomableClickableLabel(path)
        lbl.setFixedSize(280, 280)
        lbl.is_thumbnail_view = True # Desactivamos el zoom complejo para esta vista

        # Datos técnicos
        w, h, size_mb = 0, 0, 0
        try:
            size_mb = os.path.getsize(path) / (1024*1024)
            pix = QPixmap(path)

            if not pix.isNull():
                lbl.setOriginalPixmap(pix) # Guardamos referencia interna

                # --- CORRECCIÓN IMPORTANTE ---
                # Asignamos explícitamente el pixmap escalado para que se vea
                lbl.setPixmap(pix.scaled(lbl.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation))
                # -----------------------------

                w, h = pix.width(), pix.height()
            else:
                lbl.setText("Sin vista previa")
        except:
            pass

        layout.addWidget(lbl)

        # Info (Resolución, Peso, Nombre)
        info_layout = QVBoxLayout()
        res_lbl = QLabel(f"📏 {w} x {h} px")
        res_lbl.setStyleSheet("color: #4dbef9; font-weight: bold;")
        res_lbl.setAlignment(Qt.AlignCenter)
        info_layout.addWidget(res_lbl)

        size_lbl = QLabel(f"💾 {size_mb:.2f} MB")
        size_lbl.setStyleSheet("color: #aaaaaa;")
        size_lbl.setAlignment(Qt.AlignCenter)
        info_layout.addWidget(size_lbl)

        name_lbl = QLabel(Path(path).name)
        name_lbl.setWordWrap(True)
        name_lbl.setAlignment(Qt.AlignCenter)
        # Limitamos el largo del nombre para que no descuadre
        name_lbl.setStyleSheet("font-size: 10px;")
        info_layout.addWidget(name_lbl)

        layout.addLayout(info_layout)

        # Botón Borrar
        btn_del = QPushButton("🗑️ Borrar ésta")
        btn_del.setStyleSheet("background-color: #d32f2f; color: white; font-weight: bold; padding: 5px;")
        btn_del.clicked.connect(lambda: self._delete_file(path, card))
        layout.addWidget(btn_del)

        self.preview_layout.addWidget(card)

    def _delete_file(self, path, card_widget):
        reply = QMessageBox.question(self, "Confirmar", f"¿Borrar definitivamente?\n{Path(path).name}", QMessageBox.Yes | QMessageBox.No)
        if reply == QMessageBox.Yes:
            try:
                # 1. Borrar de DB
                self.db.delete_photo_permanently(path)
                # 2. Borrar de Disco
                if os.path.exists(path):
                    os.remove(path)

                self.deleted_paths.add(path)
                card_widget.deleteLater()

                # Refrescar lista automáticamente tras 200ms
                QTimer.singleShot(200, lambda: self._on_group_selected(self.list_widget.currentRow()))
            except Exception as e:
                QMessageBox.warning(self, "Error", f"No se pudo borrar: {e}")

    def get_deleted_items(self):
        return list(self.deleted_paths)

# =================================================================
# WORKER PARA MOVER A CAJA FUERTE (Evita congelamientos con vídeos)
# =================================================================
class MoveToSafeWorker(QObject):
    progress = Signal(str)
    item_finished = Signal(str, bool) # Envía (path, is_video) cuando termina uno
    finished = Signal()

    def __init__(self, db_path, items_data, password):
        """
        items_data: Lista de tuplas [(path, is_video), ...]
        """
        super().__init__()
        self.db_path = db_path
        self.items_data = items_data
        self.password = password
        self.is_running = True

    @Slot()
    def run(self):
        # Conexión DB independiente para este hilo
        local_db = VisageVaultDB(os.path.basename(self.db_path), is_worker=True)
        local_db.db_path = self.db_path
        local_db.conn = sqlite3.connect(self.db_path, check_same_thread=False)
        local_db.conn.row_factory = sqlite3.Row

        safe_dir = Path("visagevault_safe")
        safe_dir.mkdir(exist_ok=True)
        cache_dir = Path("visagevault_cache") / "local_snapshot_cache"

        total = len(self.items_data)

        for i, (original_path, is_video) in enumerate(self.items_data):
            if not self.is_running: break

            if not os.path.exists(original_path): continue

            try:
                filename = Path(original_path).name
                self.progress.emit(f"Encriptando ({i+1}/{total}): {filename}...")

                # 1. Calcular rutas
                safe_filename = hashlib.md5(original_path.encode()).hexdigest() + ".enc"
                encrypted_path = safe_dir / safe_filename

                # 2. Generar THUMBNAIL ENCRIPTADO (Solo Vídeos)
                if is_video:
                    # Generar miniatura temporal
                    thumb_temp_path = generate_video_thumbnail(original_path)

                    if thumb_temp_path and os.path.exists(thumb_temp_path):
                        encrypted_thumb_path = str(encrypted_path) + ".thumb"
                        # Encriptar miniatura
                        CryptoManager.process_file(thumb_temp_path, encrypted_thumb_path, self.password)
                        # Borrar temporal
                        os.remove(thumb_temp_path)

                # 3. ENCRIPTAR ARCHIVO PRINCIPAL (Esto es lo que tardaba)
                CryptoManager.process_file(original_path, encrypted_path, self.password)

                # 4. GUARDAR EN DB
                year, month = "0000", "00"
                if is_video:
                    # Usamos el método de la instancia local
                    cur = local_db.conn.execute("SELECT year, month FROM videos WHERE filepath = ?", (original_path,))
                    row = cur.fetchone()
                    if row: year, month = row['year'], row['month']
                else:
                    cur = local_db.conn.execute("SELECT year, month FROM photos WHERE filepath = ?", (original_path,))
                    row = cur.fetchone()
                    if row: year, month = row['year'], row['month']

                date_str = f"{year}-{month}"
                media_type = 'video' if is_video else 'photo'

                # Insertar en tabla safe_files
                local_db.conn.execute("""
                    INSERT INTO safe_files (original_path, encrypted_path, media_type, original_date)
                    VALUES (?, ?, ?, ?)
                """, (str(original_path), str(encrypted_path), media_type, date_str))
                local_db.conn.commit()

                # 5. LIMPIEZA (Borrar original y referencias)
                if is_video:
                    local_db.conn.execute("DELETE FROM videos WHERE filepath = ?", (original_path,))
                else:
                    # Borrar foto y caras asociadas
                    cur = local_db.conn.execute("SELECT id FROM photos WHERE filepath = ?", (original_path,))
                    row = cur.fetchone()
                    if row:
                        local_db.conn.execute("DELETE FROM faces WHERE photo_id = ?", (row['id'],))
                    local_db.conn.execute("DELETE FROM photos WHERE filepath = ?", (original_path,))

                local_db.conn.commit()

                # Borrar miniatura de caché pública si existe
                try:
                    thumb_hash = hashlib.sha256(str(original_path).encode('utf-8')).hexdigest()
                    thumb_file = cache_dir / f"{thumb_hash}.jpg"
                    if thumb_file.exists(): os.remove(thumb_file)
                except: pass

                # Borrar archivo original del disco
                os.remove(original_path)

                # Avisar al hilo principal para que actualice la UI
                self.item_finished.emit(original_path, is_video)

            except Exception as e:
                print(f"Error en worker safe con {original_path}: {e}")

        local_db.conn.close()
        self.finished.emit()

# =================================================================
# VENTANA PRINCIPAL DE LA APLICACIÓN (VisageVaultApp)
# =================================================================
class VisageVaultApp(QMainWindow):
    # Señales para controlar la velocidad del descargador de fotos
    set_drive_priority_low = Signal(bool)  # True = Modo Lento, False = Normal

    def __init__(self):
        super().__init__()
        self.setWindowTitle("VisageVault")
        icon_path = resource_path("visagevault.png")
        if os.path.exists(icon_path):
            self.setWindowIcon(QIcon(icon_path))
        else:
            print(f"Advertencia: No se pudo encontrar el icono en {icon_path}")

        # --- CORRECCIÓN DE RUTAS (SOPORTE LINUX/AUR) ---
        base_dir = os.path.dirname(os.path.abspath(__file__))

        # Detectamos si tenemos permiso para escribir en la carpeta del programa (Modo Portable/Dev)
        if os.access(base_dir, os.W_OK):
            # Estamos desarrollando o es un .exe portable
            self.data_dir = base_dir
            self.cache_dir = os.path.join(base_dir, "visagevault_cache")
        else:
            # Estamos instalados en /usr/share (Modo Sistema/AUR)
            # Usamos los estándares XDG de Linux
            user_home = os.path.expanduser("~")

            # Para base de datos y config: ~/.local/share/visagevault
            self.data_dir = os.path.join(user_home, ".local", "share", "visagevault")

            # Para caché (imágenes): ~/.cache/visagevault
            self.cache_dir = os.path.join(user_home, ".cache", "visagevault")

        # Crear directorios si no existen
        os.makedirs(self.data_dir, exist_ok=True)
        os.makedirs(self.cache_dir, exist_ok=True)

        # Asignar a la variable que usas en el resto del código
        self.root_cache = self.cache_dir

        # Subcarpetas de caché
        os.makedirs(os.path.join(self.root_cache, "face_cache"), exist_ok=True)
        os.makedirs(os.path.join(self.root_cache, "drive_cache"), exist_ok=True)
        os.makedirs(os.path.join(self.root_cache, "drive_snapshot_cache"), exist_ok=True)

        # --- IMPORTANTE: INICIALIZAR DB EN LA RUTA CORRECTA ---
        # Si no especificamos ruta, intentará crearla en /usr/share y fallará también
        db_path = os.path.join(self.data_dir, "visagevault.db")
        self.db = VisageVaultDB(db_path) # Asegúrate que tu clase DB acepte rutas absolutas

        self.refresh_timer = QTimer()
        self.refresh_timer.setSingleShot(True)
        self.refresh_timer.setInterval(2000) # Esperar 2 segundos de inactividad antes de refrescar
        self.refresh_timer.timeout.connect(self._perform_auto_refresh)

        self.file_watcher = None

        self.setMinimumSize(QSize(900, 600))
        self.current_directory = None

        # --- Configuración de Zoom de Miniaturas ---
        self.current_thumbnail_size = config_manager.get_thumbnail_size()
        self.MIN_THUMB_SIZE = 64   # Tamaño mínimo (ej: 64px)
        self.MAX_THUMB_SIZE = 256  # Tamaño máximo (ej: 256px)
        self.THUMB_SIZE_STEP = 16  # Píxeles por paso de zoom

        # --- Variables de Fotos ---
        self.photos_by_year_month = {}
        self.photo_thread = None
        self.photo_worker = None
        # REFACTOR: Diccionario para mapear path -> QListWidgetItem
        self.photo_list_widget_items = {}


        # --- Variables de Vídeos ---
        self.videos_by_year_month = {}
        self.video_thread = None
        self.video_worker = None
        # REFACTOR: Diccionario para mapear path -> QListWidgetItem
        self.video_list_widget_items = {}


        # --- Variables de Caras ---
        self.face_scan_thread = None
        self.face_scan_worker = None
        self.face_loading_label = None
        self.current_face_count = 0

        # --- Variables de Nube ---
        self.drive_photos_by_date = {}
        self.cloud_group_widgets = {}
        self.cloud_photo_count = 0
        self.current_drive_folder_id = None
        self.drive_scan_thread = None
        self.drive_scan_worker = None
        self.drive_loaded_ids = set()
        self.is_drive_connected = False
        self.active_folder_threads = []
        self.current_drive_folder_name = "Inicio"

        # --- Variables para filtrado local ---
        self.current_photo_filter_path = None
        self.current_video_filter_path = None

        # --- Hilos y Señales ---
        self.threadpool = QThreadPool()
        self.threadpool.setMaxThreadCount(os.cpu_count() or 4)

        # Usamos la MISMA señal para todas las miniaturas (fotos, vídeos, caras)
        self.thumb_signals = ThumbnailLoaderSignals()
        self.thumb_signals.thumbnail_loaded.connect(self._update_thumbnail)
        self.thumb_signals.load_failed.connect(self._handle_thumbnail_failed)

        self.face_loader_signals = FaceLoaderSignals()
        self.face_loader_signals.face_loaded.connect(self._handle_face_loaded)
        self.face_loader_signals.face_load_failed.connect(self._handle_face_load_failed)

        self.cluster_queue = []
        self.cluster_signals = ClusterSignals()
        self.cluster_signals.clusters_found.connect(self._handle_clusters_found)
        self.cluster_signals.clustering_progress.connect(self._set_status)
        self.cluster_signals.clustering_finished.connect(self._handle_clustering_finished)

        self.resize_timer = QTimer(self)
        self.resize_timer.setSingleShot(True)
        self.resize_timer.setInterval(200)
        self.resize_timer.timeout.connect(self._handle_resize_timeout)

        self._setup_ui()

        # --- PRECARGA INTELIGENTE ---
        # 1. Configuración inicial
        QTimer.singleShot(100, self._initial_check)
        QTimer.singleShot(500, self._check_auto_login)

        # 2. 🔥 ELIMINAR RETARDO DE PESTAÑAS: Cargar datos pesados al arrancar
        # Lo lanzamos a los 800ms para no frenar la apertura de la ventana
        QTimer.singleShot(800, self._preload_heavy_tabs)

    # --- AÑADIR ESTE NUEVO MÉTODO ---
    def _preload_heavy_tabs(self):
        """Carga los datos de Personas y Nube en segundo plano al iniciar."""
        # 1. Cargar lista de nombres de personas (DB Query + TreeWidget)
        self._load_people_list()

        # 2. Cargar rejilla de caras (DB Query + Widgets)
        self._load_existing_faces_async()

        # (La Nube ya se precarga sola con _check_auto_login -> _scan_drive_content)
        self._set_status("Aplicación lista y precargada.")

    def _setup_ui(self):
        # 1. Crear el QTabWidget
        self.tab_widget = QTabWidget()

        # ==========================================================
        # 2. Pestaña "Fotos"
        # ==========================================================
        fotos_tab_widget = QWidget()
        fotos_layout = QVBoxLayout(fotos_tab_widget)
        fotos_layout.setContentsMargins(0, 0, 0, 0)

        self.main_splitter = QSplitter(Qt.Horizontal)

        # --- NUEVO: Panel Izquierdo (Árbol de Carpetas Local) ---
        self.photo_folder_panel = QWidget()
        self.photo_folder_panel.setMinimumWidth(200)
        photo_folder_layout = QVBoxLayout(self.photo_folder_panel)
        photo_folder_layout.setContentsMargins(0, 0, 0, 0)

        lbl_folder_photo = QLabel("Directorios:")
        lbl_folder_photo.setStyleSheet("font-weight: bold; color: #3daee9; padding: 5px;")
        photo_folder_layout.addWidget(lbl_folder_photo)

        self.photo_folder_tree = QTreeWidget()
        self.photo_folder_tree.setHeaderHidden(True)
        self.photo_folder_tree.itemExpanded.connect(self._on_local_folder_tree_expanded)
        self.photo_folder_tree.itemClicked.connect(self._on_photo_folder_tree_clicked)
        photo_folder_layout.addWidget(self.photo_folder_tree)

        self.main_splitter.addWidget(self.photo_folder_panel)
        self.photo_folder_panel.hide() # Oculto por defecto
        # ------------------------------------------------------

        # Panel Central (Fotos) - ANTES ERA IZQUIERDO
        photo_area_widget = QWidget()
        self.photo_container_layout = QVBoxLayout(photo_area_widget)
        self.photo_container_layout.setSpacing(0)
        self.scroll_area = QScrollArea()
        self.scroll_area.setWidgetResizable(True)
        self.scroll_area.setWidget(photo_area_widget)
        self.scroll_area.verticalScrollBar().valueChanged.connect(self._debounced_thumbnail_load)
        self.scroll_area.verticalScrollBar().valueChanged.connect(self._on_photo_scroll_changed)
        self.main_splitter.addWidget(self.scroll_area)

        # Panel Derecho (Navegación de Fotos)
        photo_right_panel_widget = QWidget()
        photo_right_panel_layout = QVBoxLayout(photo_right_panel_widget)

        # Controles superiores
        top_controls = QVBoxLayout()
        botones_layout = QHBoxLayout()

        self.select_dir_button = QPushButton("Cambiar Directorio")
        self.select_dir_button.clicked.connect(self._open_directory_dialog)
        botones_layout.addWidget(self.select_dir_button)

        self.btn_duplicates = QPushButton("Buscar Duplicados")
        self.btn_duplicates.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_BrowserReload))
        self.btn_duplicates.clicked.connect(self._start_duplicate_search)
        botones_layout.addWidget(self.btn_duplicates)

        top_controls.addLayout(botones_layout)

        # --- NUEVO: Botón Ver Árbol ---
        self.btn_show_photo_tree = QPushButton("Ver árbol de directorios")
        self.btn_show_photo_tree.setCheckable(True)
        self.btn_show_photo_tree.clicked.connect(self._toggle_photo_folder_tree)
        top_controls.addWidget(self.btn_show_photo_tree)
        # ------------------------------

        self.path_label = QLabel("Ruta: No configurada")
        self.path_label.setWordWrap(True)
        top_controls.addWidget(self.path_label)
        photo_right_panel_layout.addLayout(top_controls)

        photo_year_label = QLabel("Navegación por Fecha (Fotos):")
        photo_right_panel_layout.addWidget(photo_year_label)
        self.date_tree_widget = QTreeWidget()
        self.date_tree_widget.setHeaderHidden(True)
        self.date_tree_widget.currentItemChanged.connect(self._scroll_to_item)
        photo_right_panel_layout.addWidget(self.date_tree_widget)

        self.main_splitter.addWidget(photo_right_panel_widget)
        fotos_layout.addWidget(self.main_splitter)

        # Ajustar tamaños iniciales (Árbol oculto (0), Fotos, Panel Derecho)
        self.main_splitter.setSizes([0, 800, 200])

        # ==========================================================
        # 3. Pestaña "Vídeos"
        # ==========================================================
        videos_tab_widget = QWidget()
        videos_layout = QVBoxLayout(videos_tab_widget)
        videos_layout.setContentsMargins(0, 0, 0, 0)

        self.video_splitter = QSplitter(Qt.Horizontal)

        # --- NUEVO: Panel Izquierdo (Árbol de Carpetas Local Vídeos) ---
        self.video_folder_panel = QWidget()
        self.video_folder_panel.setMinimumWidth(200)
        video_folder_layout = QVBoxLayout(self.video_folder_panel)
        video_folder_layout.setContentsMargins(0, 0, 0, 0)

        lbl_folder_video = QLabel("Directorios:")
        lbl_folder_video.setStyleSheet("font-weight: bold; color: #3daee9; padding: 5px;")
        video_folder_layout.addWidget(lbl_folder_video)

        self.video_folder_tree = QTreeWidget()
        self.video_folder_tree.setHeaderHidden(True)
        self.video_folder_tree.itemExpanded.connect(self._on_local_folder_tree_expanded)
        self.video_folder_tree.itemClicked.connect(self._on_video_folder_tree_clicked)
        video_folder_layout.addWidget(self.video_folder_tree)

        self.video_splitter.addWidget(self.video_folder_panel)
        self.video_folder_panel.hide()
        # -------------------------------------------------------------

        # Panel Central (Vídeos)
        video_area_widget = QWidget()
        self.video_container_layout = QVBoxLayout(video_area_widget)
        self.video_container_layout.setSpacing(0)
        self.video_scroll_area = QScrollArea()
        self.video_scroll_area.setWidgetResizable(True)
        self.video_scroll_area.setWidget(video_area_widget)
        self.video_scroll_area.verticalScrollBar().valueChanged.connect(self._load_visible_video_thumbnails)
        self.video_scroll_area.verticalScrollBar().valueChanged.connect(self._on_video_scroll_changed)
        self.video_splitter.addWidget(self.video_scroll_area)

        # Panel Derecho (Navegación de Vídeos)
        video_right_panel_widget = QWidget()
        video_right_panel_layout = QVBoxLayout(video_right_panel_widget)

        # --- NUEVO: Botonera superior para Vídeos ---
        video_top_controls = QVBoxLayout()
        self.btn_show_video_tree = QPushButton("Ver árbol de directorios")
        self.btn_show_video_tree.setCheckable(True)
        self.btn_show_video_tree.clicked.connect(self._toggle_video_folder_tree)
        video_top_controls.addWidget(self.btn_show_video_tree)
        video_right_panel_layout.addLayout(video_top_controls)
        # --------------------------------------------

        video_year_label = QLabel("Navegación por Fecha (Vídeos):")
        video_right_panel_layout.addWidget(video_year_label)
        self.video_date_tree_widget = QTreeWidget()
        self.video_date_tree_widget.setHeaderHidden(True)
        self.video_date_tree_widget.currentItemChanged.connect(self._scroll_to_video_item)
        video_right_panel_layout.addWidget(self.video_date_tree_widget)

        video_right_panel_layout.addSpacerItem(QSpacerItem(20, 40, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding))

        self.video_splitter.addWidget(video_right_panel_widget)
        videos_layout.addWidget(self.video_splitter)

        # Ajustar tamaños iniciales
        self.video_splitter.setSizes([0, 800, 200])


        # ==========================================================
        # 4. Pestaña "Personas" (Sin cambios)
        # ==========================================================
        self.personas_tab_widget = QWidget()
        personas_layout = QVBoxLayout(self.personas_tab_widget)
        personas_layout.setContentsMargins(0, 0, 0, 0)
        self.people_splitter = QSplitter(Qt.Horizontal)
        self.left_people_stack = QStackedWidget()

        # Pagina 0: Cuadrícula de Caras
        face_area_widget = QWidget()
        self.face_container_layout = QVBoxLayout(face_area_widget)
        self.unknown_faces_group = QGroupBox("Caras Sin Asignar")
        self.unknown_faces_layout = QGridLayout(self.unknown_faces_group)
        self.unknown_faces_layout.setSpacing(10)
        self.face_container_layout.addWidget(self.unknown_faces_group)
        self.face_container_layout.addStretch(1)
        self.face_scroll_area = QScrollArea()
        self.face_scroll_area.setWidgetResizable(True)
        self.face_scroll_area.setWidget(face_area_widget)
        self.left_people_stack.addWidget(self.face_scroll_area)

        # Pagina 1: Cuadrícula de Fotos de Persona
        self.person_photo_scroll_area = QScrollArea()
        self.person_photo_scroll_area.setWidgetResizable(True)
        person_photo_widget = QWidget()
        self.person_photo_layout = QVBoxLayout(person_photo_widget)
        self.person_photo_scroll_area.setWidget(person_photo_widget)
        self.person_photo_scroll_area.verticalScrollBar().valueChanged.connect(self._load_person_visible_thumbnails)
        self.left_people_stack.addWidget(self.person_photo_scroll_area)
        self.people_splitter.addWidget(self.left_people_stack)

        # Panel Derecho (Personas)
        people_panel_widget = QWidget()
        people_panel_layout = QVBoxLayout(people_panel_widget)
        people_panel_widget.setMinimumWidth(180)
        people_panel_widget.setMaximumWidth(450)
        people_label = QLabel("Navegación por Personas:")
        people_panel_layout.addWidget(people_label)
        self.people_tree_widget = QTreeWidget()
        self.people_tree_widget.setHeaderHidden(True)
        self.people_tree_widget.currentItemChanged.connect(self._on_person_selected)
        people_panel_layout.addWidget(self.people_tree_widget)
        self.show_deleted_faces_button = QPushButton("Ver caras eliminadas")
        self.show_deleted_faces_button.clicked.connect(self._show_deleted_faces)
        people_panel_layout.addWidget(self.show_deleted_faces_button)
        self.cluster_faces_button = QPushButton("Buscar Duplicados")
        self.cluster_faces_button.clicked.connect(self._start_clustering)
        people_panel_layout.addWidget(self.cluster_faces_button)
        self.people_splitter.addWidget(people_panel_widget)
        personas_layout.addWidget(self.people_splitter)
        default_width = self.width()
        min_right_width = 180
        left_width = default_width - min_right_width
        if left_width < 100: left_width = 100
        self.people_splitter.setSizes([left_width, min_right_width])

        # ==========================================================
        # 5. Pestaña "Ayuda" (NUEVO)
        # ==========================================================
        help_tab_widget = QWidget()
        help_layout = QVBoxLayout(help_tab_widget)
        help_layout.setAlignment(Qt.AlignCenter)

        # Logo grande en la pestaña
        tab_logo = QLabel()
        logo_path = resource_path("visagevault.png")
        if os.path.exists(logo_path):
            pixmap = QPixmap(logo_path)
            tab_logo.setPixmap(pixmap.scaled(256, 256, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        # Ajuste fino para centrar ópticamente si la imagen tiene márgenes desiguales
        tab_logo.setStyleSheet("margin-left: 100px;") # Prueba valores pequeños
        help_layout.addWidget(tab_logo)

        help_layout.addSpacing(20)

        # Texto de bienvenida
        welcome_label = QLabel("<h1>Bienvenido a VisageVault</h1>")
        welcome_label.setAlignment(Qt.AlignCenter)
        help_layout.addWidget(welcome_label)

        subtitle_label = QLabel("Tu gestor de recuerdos inteligente, privado y local.")
        subtitle_label.setStyleSheet("font-size: 14pt; color: gray;")
        subtitle_label.setAlignment(Qt.AlignCenter)
        help_layout.addWidget(subtitle_label)

        help_layout.addSpacing(40)

        # Botón para abrir el diálogo
        btn_open_help = QPushButton("  Ver Ayuda / Acerca de / Contacto  ")
        btn_open_help.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MessageBoxInformation))
        btn_open_help.setStyleSheet("""
            QPushButton {
                font-size: 14pt;
                padding: 15px;
                border-radius: 8px;
                background-color: #3daee9;
                color: white;
                font-weight: bold;
            }
            QPushButton:hover { background-color: #4dbef9; }
        """)
        btn_open_help.setCursor(Qt.PointingHandCursor)
        btn_open_help.clicked.connect(self._open_help_dialog) # Conectamos a la función

        help_layout.addWidget(btn_open_help)
        help_layout.addStretch(1)

        # ==========================================================
        # PESTAÑA NUBE (Google Drive) - MODIFICADA
        # ==========================================================
        self.cloud_tab = QWidget()
        cloud_layout = QVBoxLayout(self.cloud_tab)

        # 1. Cabecera (Botón Login, Cambiar Carpeta y Ver Árbol)
        header_layout = QHBoxLayout()
        self.btn_gdrive = QPushButton("Iniciar sesión con Google")
        self.btn_gdrive.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_DriveNetIcon))
        self.btn_gdrive.clicked.connect(self._on_gdrive_login_click)
        header_layout.addWidget(self.btn_gdrive)

        self.btn_change_folder = QPushButton("Cambiar Carpeta")
        self.btn_change_folder.setVisible(False)
        self.btn_change_folder.clicked.connect(self._select_drive_folder)
        header_layout.addWidget(self.btn_change_folder)

        # --- NUEVO BOTÓN: VER ÁRBOL ---
        self.btn_show_tree = QPushButton("Ver árbol de directorios")
        self.btn_show_tree.setCheckable(True) # Funciona como interruptor On/Off
        self.btn_show_tree.setVisible(False)  # Oculto hasta iniciar sesión
        self.btn_show_tree.clicked.connect(self._toggle_drive_folder_tree)
        header_layout.addWidget(self.btn_show_tree)
        # ------------------------------

        header_layout.addStretch() # Empujar botones a la izquierda
        cloud_layout.addLayout(header_layout)

        # 2. Splitter Principal (Árbol Carpetas | Fotos | Árbol Fechas)
        self.cloud_splitter = QSplitter(Qt.Horizontal)

        # --- NUEVO PANEL IZQUIERDO: ÁRBOL DE DIRECTORIOS ---
        self.cloud_folder_panel = QWidget()
        folder_panel_layout = QVBoxLayout(self.cloud_folder_panel)
        folder_panel_layout.setContentsMargins(0, 0, 0, 0)

        folder_label = QLabel("Subcarpetas:")
        folder_label.setStyleSheet("font-weight: bold; color: #3daee9; padding: 5px;")
        folder_panel_layout.addWidget(folder_label)

        self.cloud_folder_tree = QTreeWidget()
        self.cloud_folder_tree.setHeaderHidden(True)
        # Conectamos la expansión para carga perezosa (lazy loading)
        self.cloud_folder_tree.itemExpanded.connect(self._on_folder_tree_item_expanded)

        self.cloud_folder_tree.itemClicked.connect(self._on_folder_tree_item_clicked)

        folder_panel_layout.addWidget(self.cloud_folder_tree)

        # Lo añadimos al splitter y lo ocultamos por defecto (se activa con el botón)
        self.cloud_splitter.addWidget(self.cloud_folder_panel)
        self.cloud_folder_panel.hide()
        # ---------------------------------------------------

        # --- PANEL CENTRAL: Área de Scroll para las Fotos ---
        cloud_area_widget = QWidget()
        self.cloud_container_layout = QVBoxLayout(cloud_area_widget)
        self.cloud_container_layout.setSpacing(0)

        self.cloud_scroll_area = QScrollArea()
        self.cloud_scroll_area.setWidgetResizable(True)
        self.cloud_scroll_area.setWidget(cloud_area_widget)

        # Conectamos el scroll para cargar miniaturas bajo demanda (Lazy Loading)
        self.cloud_scroll_area.verticalScrollBar().valueChanged.connect(self._load_visible_cloud_thumbnails)
        self.cloud_scroll_area.verticalScrollBar().valueChanged.connect(self._on_cloud_scroll_changed)

        self.cloud_splitter.addWidget(self.cloud_scroll_area)

        # --- PANEL DERECHO: Árbol de Fechas ---
        cloud_right_panel = QWidget()
        cloud_right_layout = QVBoxLayout(cloud_right_panel)

        cloud_right_layout.addWidget(QLabel("Navegación Nube:"))
        self.cloud_date_tree = QTreeWidget()
        self.cloud_date_tree.setHeaderHidden(True)
        self.cloud_date_tree.currentItemChanged.connect(self._scroll_to_cloud_item)
        cloud_right_layout.addWidget(self.cloud_date_tree)

        self.cloud_splitter.addWidget(cloud_right_panel)

        # Ajustar tamaños iniciales (20% árbol, 60% fotos, 20% fechas)
        self.cloud_splitter.setSizes([200, 600, 200])

        cloud_layout.addWidget(self.cloud_splitter)

        # Variables de memoria para la nube
        self.drive_photos_by_date = {} # Estructura: { '2023': { '01': [datos_foto, ...] } }
        self.cloud_group_widgets = {}  # Para el scroll automático
        self.cloud_photo_count = 0

        # ==========================================================
        # 6. Añadir pestañas al Widget Central (MODIFICADO)
        # ==========================================================
        self.tab_widget.addTab(fotos_tab_widget, "Fotos")
        self.tab_widget.addTab(videos_tab_widget, "Vídeos")
        self.tab_widget.addTab(self.personas_tab_widget, "Personas")
        self.safe_tab = QWidget()
        self._setup_safe_tab() # Función auxiliar que crearemos abajo
        self.tab_widget.addTab(self.safe_tab, "Caja Fuerte")
        self.tab_widget.addTab(self.cloud_tab, "Nube")
        self.tab_widget.addTab(help_tab_widget, "Ayuda")

        self.setCentralWidget(self.tab_widget)

        # ==========================================================
        # 7. Cargar estado de los splitters
        # ==========================================================
        photo_right_panel_widget.setMinimumWidth(180)
        # self.main_splitter.splitterMoved.connect(self._save_photo_splitter_state)
        self._load_photo_splitter_state()

        video_right_panel_widget.setMinimumWidth(180)
        # self.video_splitter.splitterMoved.connect(self._save_video_splitter_state)
        self._load_video_splitter_state() # <-- NUEVO

        self.tab_widget.currentChanged.connect(self._on_tab_changed)

    # ----------------------------------------------------
    # Lógica de Inicio y Configuración
    # ----------------------------------------------------

    def _initial_check(self):
        """Comprueba la configuración al arrancar la app."""

        # --- NUEVA COMPROBACIÓN DE AUTOREPARACIÓN ---
        if self.db.was_reset:
            QMessageBox.warning(
                self,
                "Autoreparación Realizada",
                "Se detectó un problema en la base de datos y ha sido reiniciada.\n\n"
                "✅ TUS DATOS ESTÁN A SALVO: Hemos restaurado tus fechas personalizadas y archivos ocultos.\n"
                "ℹ️ El escáner de caras y miniaturas se ejecutará de nuevo para reconstruir el caché."
            )
        # --------------------------------------------

        directory = config_manager.get_photo_directory()
        if directory and Path(directory).is_dir():
            self.current_directory = directory
            self.path_label.setText(f"Ruta: {Path(directory).name}")
            self._start_media_scan(directory)
        else:
            self._set_status("No se encontró un directorio válido. Por favor, selecciona uno.")
            self._open_directory_dialog(force_select=True)

    def _open_directory_dialog(self, force_select=False):
        """Abre el selector de directorios y gestiona la carga."""

        # 1. Definir la variable 'directory' abriendo el diálogo
        directory = QFileDialog.getExistingDirectory(
            self,
            "Seleccionar Carpeta de Fotos",
            self.current_directory or ""
        )

        if directory:
            self.current_directory = directory
            config_manager.set_photo_directory(directory)
            self.path_label.setText(f"Ruta: {Path(directory).name}")

            # Resetear filtros
            self.current_photo_filter_path = None
            self.current_video_filter_path = None

            # Recargar árboles si están visibles
            if self.btn_show_photo_tree.isChecked():
                self._load_local_tree_root(self.photo_folder_tree, directory)
            else:
                self.photo_folder_tree.clear()

            if self.btn_show_video_tree.isChecked():
                self._load_local_tree_root(self.video_folder_tree, directory)
            else:
                self.video_folder_tree.clear()

            # Limpiar y escanear
            self.date_tree_widget.clear()
            self.video_date_tree_widget.clear()
            self._start_media_scan(directory)

        elif force_select:
             self._set_status("¡Debes seleccionar un directorio para comenzar!")

    # ----------------------------------------------------
    # Lógica de Hilos y Resultados
    # ----------------------------------------------------

    def _start_media_scan(self, directory):
        """Inicia los escaneos de fotos y vídeos."""
        if not directory:
            return

        if self.file_watcher:
            self.file_watcher.stop()

        self.file_watcher = PhotoDirWatcher(directory)
        self.file_watcher.directory_changed.connect(self._on_directory_changed)
        self.file_watcher.start()

        self._start_photo_search(directory)
        self._start_video_search(directory)

    @Slot()
    def _on_directory_changed(self):
        """Se llama cuando watchdog detecta un cambio. Reinicia el temporizador."""
        # Cada vez que hay un cambio, reiniciamos la cuenta atrás.
        # Solo se ejecutará _perform_auto_refresh cuando pasen 2 segundos SIN cambios.
        self.refresh_timer.start()

    @Slot()
    def _perform_auto_refresh(self):
        """Ejecuta el re-escaneo real tras el periodo de calma."""
        # print("Detectados cambios en el disco. Actualizando galería...")
        self._set_status("Detectados cambios externos. Actualizando...")

        if self.current_directory:
            # Relanzamos los escaneos.
            # Nota: Tus workers actuales son inteligentes (usan fechas de la BD),
            # pero para detectar archivos NUEVOS o BORRADOS necesitan recorrer el disco.
            self._start_photo_search(self.current_directory)
            self._start_video_search(self.current_directory)
            # El escaneo de caras se lanzará solo al terminar el de fotos

    def _start_photo_search(self, directory):
        """Configura y lanza el trabajador de escaneo de FOTOS."""
        if self.photo_thread and self.photo_thread.isRunning():
            self._set_status("El escaneo de fotos anterior sigue en curso.")
            return

        self.photo_thread = QThread()
        self.photo_worker = PhotoFinderWorker(directory, self.db.db_path)
        self.photo_worker.moveToThread(self.photo_thread)

        self.photo_thread.started.connect(self.photo_worker.run)
        self.photo_worker.finished.connect(self._handle_search_finished)
        self.photo_worker.progress.connect(self._set_status)

        self.photo_worker.finished.connect(self.photo_thread.quit)
        self.photo_worker.finished.connect(self.photo_worker.deleteLater)
        self.photo_thread.finished.connect(self._on_scan_thread_finished)

        self.select_dir_button.setEnabled(False)
        self.photo_thread.start()

    # --- NUEVA FUNCIÓN ---
    def _start_video_search(self, directory):
        """Configura y lanza el trabajador de escaneo de VÍDEOS."""
        if self.video_thread and self.video_thread.isRunning():
            self._set_status("El escaneo de vídeos anterior sigue en curso.")
            return

        self.video_thread = QThread()
        self.video_worker = VideoFinderWorker(directory, self.db.db_path)
        self.video_worker.moveToThread(self.video_thread)

        self.video_thread.started.connect(self.video_worker.run)
        self.video_worker.finished.connect(self._handle_video_search_finished)
        self.video_worker.progress.connect(self._set_status) # Ambos workers reportan al mismo status_label

        self.video_worker.finished.connect(self.video_thread.quit)
        self.video_worker.finished.connect(self.video_worker.deleteLater)
        self.video_thread.finished.connect(self._on_video_scan_thread_finished)

        self.select_dir_button.setEnabled(False) # Compartido
        self.video_thread.start()
    # --- FIN DE LO NUEVO ---

    # ----------------------------------------------------
    # Escaneo de caras (Sin cambios)
    # ----------------------------------------------------
    def _start_face_scan(self):
        """Configura y lanza el trabajador de escaneo de caras."""
        if self.face_scan_thread and self.face_scan_thread.isRunning():
            self._set_status("El escaneo de caras ya está en curso.")
            return
        self.face_scan_thread = QThread()
        self.face_scan_worker = FaceScanWorker(self.db.db_path)
        self.face_scan_worker.moveToThread(self.face_scan_thread)
        self.face_scan_worker.signals.scan_progress.connect(self._set_status)
        self.face_scan_worker.signals.scan_percentage.connect(self._update_face_scan_percentage)
        self.face_scan_worker.signals.face_found.connect(self._handle_face_found)
        self.face_scan_worker.signals.scan_finished.connect(self._handle_scan_finished)
        self.face_scan_thread.started.connect(self.face_scan_worker.run)
        self.face_scan_worker.signals.scan_finished.connect(self.face_scan_thread.quit)
        self.face_scan_worker.signals.scan_finished.connect(self.face_scan_worker.deleteLater)
        self.face_scan_thread.finished.connect(self._on_face_scan_thread_finished)
        self._set_status("Iniciando escaneo de caras...")
        self.face_scan_thread.start()

    # ----------------------------------------------------
    # Lógica de Visualización y Miniaturas
    # ----------------------------------------------------

    def _display_photos(self):
        """Muestra las FOTOS (Lógica clonada de Vídeos para corregir selección y huecos)."""
        while self.photo_container_layout.count() > 0:
            item = self.photo_container_layout.takeAt(0)
            if item.widget(): item.widget().deleteLater()

        self.date_tree_widget.clear()
        self.photo_list_widget_items.clear()
        self.photo_group_widgets = {}

        # 1. Preparar lista de ocultos
        hidden_paths = set(self.db.get_hidden_photos())
        hidden_item = QTreeWidgetItem(self.date_tree_widget, ["Ocultas"])
        hidden_item.setIcon(0, self.style().standardIcon(QStyle.StandardPixmap.SP_MessageBoxWarning))
        hidden_item.setData(0, Qt.UserRole, "HIDDEN_SECTION")

        sorted_years = sorted(self.photos_by_year_month.keys(), reverse=True)

        for year in sorted_years:
            if year == "Sin Fecha": continue
            year_item = QTreeWidgetItem(self.date_tree_widget, [str(year)])

            year_label = QLabel(f"Año {year}")
            year_label.setStyleSheet("font-size: 16pt; font-weight: bold; margin-top: 20px; margin-bottom: 5px;")
            widgets_added_for_year = [year_label]

            month_added_count = 0
            sorted_months = sorted(self.photos_by_year_month[year].keys())

            for month in sorted_months:
                if month == "00": continue
                all_photos = self.photos_by_year_month[year][month]

                # Filtrar
                visible_photos = []
                for p in all_photos:
                    if p in hidden_paths: continue
                    if self.current_photo_filter_path and not p.startswith(self.current_photo_filter_path):
                        continue
                    visible_photos.append(p)

                if not visible_photos: continue
                month_added_count += 1

                try: month_name = datetime.datetime.strptime(month, "%m").strftime("%B").capitalize()
                except: month_name = "Mes Desconocido"

                month_item = QTreeWidgetItem(year_item, [f"{month_name} ({len(visible_photos)})"])
                month_item.setData(0, Qt.UserRole, (year, month))

                month_label = QLabel(month_name)
                month_label.setStyleSheet("font-size: 14pt; font-weight: bold; margin-top: 10px;")
                widgets_added_for_year.append(month_label)
                self.photo_group_widgets[f"{year}-{month}"] = month_label

                # --- CONFIGURACIÓN LISTWIDGET EXACTA A VÍDEO ---
                list_widget = PreviewListWidget()
                list_widget.setMovement(QListWidget.Static)
                list_widget.setSelectionMode(QAbstractItemView.ExtendedSelection)

                # ¡CRUCIAL! Desactivar uniformidad para que la selección se ajuste al tamaño real
                list_widget.setUniformItemSizes(False)

                # Configuración de vista
                list_widget.setViewMode(QListWidget.IconMode)
                list_widget.setResizeMode(QListWidget.Adjust)
                list_widget.setSpacing(10) # Espacio entre fotos (ajustado para que no haya huecos grandes)

                list_widget.itemPressed.connect(self._handle_global_selection)

                # ¡CRUCIAL! Desactivar uniformidad
                list_widget.setUniformItemSizes(False)

                list_widget.setContextMenuPolicy(Qt.CustomContextMenu)
                list_widget.customContextMenuRequested.connect(
                    lambda pos, lw=list_widget: self._on_context_menu(pos, lw, is_video=False)
                )
                list_widget.previewRequested.connect(self._open_preview_dialog)
                list_widget.itemDoubleClicked.connect(self._on_photo_item_double_clicked)

                list_widget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
                list_widget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
                list_widget.setFrameShape(QFrame.NoFrame)

                # Tamaño de iconos
                thumb_size = self.current_thumbnail_size
                list_widget.setIconSize(QSize(thumb_size, thumb_size))

                # Definimos el tamaño exacto que ocupará cada item (Icono + un pequeño borde)
                item_w = thumb_size + 10
                item_h = thumb_size + 10

                for photo_path in visible_photos:
                    item = QListWidgetItem("Cargando...")
                    item.setToolTip(Path(photo_path).name)
                    # ¡CRUCIAL! Forzar el tamaño de la celda para que la selección sea correcta
                    item.setSizeHint(QSize(item_w, item_h))
                    item.setData(Qt.UserRole, photo_path)
                    item.setData(Qt.UserRole + 1, "not_loaded")
                    list_widget.addItem(item)
                    self.photo_list_widget_items[photo_path] = item

                # --- CÁLCULO DE ALTURA PARA ELIMINAR EL "GAP" ---
                # Usamos el ancho disponible menos un margen de seguridad
                viewport_width = self.scroll_area.viewport().width() - 30
                if viewport_width < 100: viewport_width = 800

                # Ancho real de cada celda incluyendo el spacing del widget
                effective_item_width = item_w + list_widget.spacing()

                # Calcular columnas
                num_cols = max(1, viewport_width // effective_item_width)

                # Calcular filas
                rows = (len(visible_photos) + num_cols - 1) // num_cols

                # Altura total = (Filas * AlturaItem) + (Filas * Espacio) + Margen extra pequeño
                total_height = (rows * item_h) + ((rows + 1) * list_widget.spacing())

                list_widget.setFixedHeight(total_height)
                widgets_added_for_year.append(list_widget)

            if month_added_count > 0:
                self.photo_container_layout.addWidget(year_label)
                self.photo_group_widgets[year] = year_label
                for i, w in enumerate(widgets_added_for_year):
                    if i == 0: continue
                    self.photo_container_layout.addWidget(w)
                year_item.setExpanded(True)
            else:
                year_item.setHidden(True)

        self.photo_container_layout.addStretch(1)
        QTimer.singleShot(100, self._load_main_visible_thumbnails)


    def _display_videos(self):
        """Muestra los VÍDEOS agrupados por fecha (FILTRANDO LOS OCULTOS)."""
        while self.video_container_layout.count() > 0:
            item = self.video_container_layout.takeAt(0)
            if item.widget(): item.widget().deleteLater()
        self.video_date_tree_widget.clear()

        self.video_list_widget_items.clear()
        self.video_group_widgets = {}

        # --- PASO 1: OBTENER LISTA NEGRA DE VÍDEOS ---
        hidden_paths = set(self.db.get_hidden_videos())
        # ---------------------------------------------

        hidden_item = QTreeWidgetItem(self.video_date_tree_widget, ["Ocultos"])
        hidden_item.setIcon(0, self.style().standardIcon(QStyle.StandardPixmap.SP_MessageBoxWarning))
        hidden_item.setData(0, Qt.UserRole, "HIDDEN_SECTION")

        sorted_years = sorted(self.videos_by_year_month.keys(), reverse=True)

        for year in sorted_years:
            if year == "Sin Fecha": continue
            year_item = QTreeWidgetItem(self.video_date_tree_widget, [str(year)])

            year_label = QLabel(f"Año {year}")
            year_label.setStyleSheet("font-size: 16pt; font-weight: bold; margin-top: 20px; margin-bottom: 5px;")

            widgets_added_for_year = [year_label]
            month_added_count = 0

            sorted_months = sorted(self.videos_by_year_month[year].keys())

            for month in sorted_months:
                if month == "00": continue
                all_videos = self.videos_by_year_month[year][month]

                # --- PASO 2: FILTRAR VÍDEOS VISIBLES ---
                # Modificado para incluir filtro de carpeta
                visible_videos = []
                for v in all_videos:
                    if v in hidden_paths: continue

                    # Filtro de carpeta
                    if self.current_video_filter_path:
                        if not v.startswith(self.current_video_filter_path):
                            continue

                    visible_videos.append(v)

                if not visible_videos:
                    continue
                # ---------------------------------------

                month_added_count += 1

                try:
                    month_name = datetime.datetime.strptime(month, "%m").strftime("%B").capitalize()
                except ValueError:
                    month_name = "Mes Desconocido"

                month_item = QTreeWidgetItem(year_item, [f"{month_name} ({len(visible_videos)})"])
                month_item.setData(0, Qt.UserRole, (year, month))

                month_label = QLabel(month_name)
                month_label.setStyleSheet("font-size: 14pt; font-weight: bold; margin-top: 10px;")
                widgets_added_for_year.append(month_label)

                self.video_group_widgets[f"{year}-{month}"] = month_label

                list_widget = PreviewListWidget()
                list_widget.setMovement(QListWidget.Static)
                list_widget.setSelectionMode(QAbstractItemView.ExtendedSelection)
                list_widget.setSpacing(20)

                list_widget.itemPressed.connect(self._handle_global_selection)

                list_widget.setContextMenuPolicy(Qt.CustomContextMenu)
                list_widget.customContextMenuRequested.connect(
                    lambda pos, lw=list_widget: self._on_context_menu(pos, lw, is_video=True)
                )

                list_widget.setViewMode(QListWidget.IconMode)
                list_widget.setResizeMode(QListWidget.Adjust)
                list_widget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
                list_widget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
                list_widget.setFrameShape(QFrame.NoFrame)
                list_widget.setToolTip("Ctrl + (+/-): Zoom\n\nHaz clic para seleccionar.")

                list_widget.itemDoubleClicked.connect(self._on_video_item_double_clicked)

                list_widget.setIconSize(QSize(self.current_thumbnail_size, self.current_thumbnail_size))

                item_w = self.current_thumbnail_size + 8
                item_h = self.current_thumbnail_size + 8

                # --- USAR LISTA FILTRADA ---
                for video_path in visible_videos:
                    item = QListWidgetItem("Cargando...")
                    item.setToolTip(Path(video_path).name)
                    item.setSizeHint(QSize(item_w, item_h))
                    item.setData(Qt.UserRole, video_path)
                    item.setData(Qt.UserRole + 1, "not_loaded")
                    list_widget.addItem(item)
                    self.video_list_widget_items[video_path] = item

                viewport_width = self.video_scroll_area.viewport().width() - 30
                thumb_width = item_w + list_widget.spacing()
                num_cols = max(1, viewport_width // thumb_width)

                rows = (len(visible_videos) + num_cols - 1) // num_cols
                total_height = (rows * item_h) + (rows * list_widget.spacing())
                list_widget.setFixedHeight(total_height)

                widgets_added_for_year.append(list_widget)

            if month_added_count > 0:
                self.video_container_layout.addWidget(year_label)
                self.video_group_widgets[year] = year_label
                for i, w in enumerate(widgets_added_for_year):
                    if i == 0: continue
                    self.video_container_layout.addWidget(w)
                year_item.setExpanded(True)
            else:
                year_item.setHidden(True)

        self.video_container_layout.addStretch(1)
        QTimer.singleShot(100, self._load_visible_video_thumbnails)

    # --- FIN DE LAS NUEVAS FUNCIONES DE DISPLAY ---

    # ----------------------------------------------------------------
    # MENÚ CONTEXTUAL ESPECÍFICO PARA DRIVE
    # ----------------------------------------------------------------
    def _on_drive_context_menu(self, pos, list_widget):
        """
        Menú clic derecho para elementos de la Nube.
        MODIFICADO: Busca selecciones en TODOS los meses.
        """
        # 1. BÚSQUEDA GLOBAL DE SELECCIÓN EN LA NUBE
        container = list_widget.parent()
        selected_items = []

        if container:
            for lw in container.findChildren(PreviewListWidget):
                selected_items.extend(lw.selectedItems())
        else:
            selected_items = list_widget.selectedItems()

        if not selected_items:
            return

        menu = QMenu(self)

        # Informativo
        count = len(selected_items)
        header = menu.addAction(f"{count} foto(s) seleccionada(s)")
        header.setEnabled(False)
        menu.addSeparator()

        # Opción: Cambiar Fecha
        action_date = menu.addAction("Cambiar Fecha (Localmente)")
        action_date.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_FileDialogDetailedView))

        action = menu.exec(list_widget.mapToGlobal(pos))

        if action == action_date:
            # Pasamos la lista acumulada de todos los meses
            self._change_date_for_drive_items(selected_items)

    def _change_date_for_drive_items(self, items):
        """
        Abre el diálogo UNA sola vez y aplica la fecha a TODAS las fotos seleccionadas de Drive.
        """
        if not items: return

        # 1. Abrir diálogo (Solo una vez para todo el grupo)
        dialog = DateChangeDialog(self)
        if dialog.exec() == QDialog.Accepted:
            new_year, new_month = dialog.get_data()

            # Fecha ISO ficticia para ordenar: YYYY-MM-01T12:00...
            new_iso_date = f"{new_year}-{new_month}-01T12:00:00.000Z"

            count = 0
            total = len(items)

            self._set_status(f"Actualizando fecha de {total} elementos en la nube (localmente)...")

            # 2. Iterar sobre TODOS los elementos seleccionados
            for i, item in enumerate(items):
                try:
                    data = item.data(Qt.UserRole)
                    if not data: continue

                    file_id = data['id']

                    # Actualizar DB
                    self.db.update_drive_photo_date(file_id, new_iso_date)

                    # Actualizar estructura en Memoria (RAM) para que el cambio sea instantáneo
                    # Buscamos y eliminamos la foto de su fecha antigua
                    found = False
                    for y, months in self.drive_photos_by_date.items():
                        for m, photos in months.items():
                            # photos es una lista de diccionarios
                            for p in photos:
                                if p['id'] == file_id:
                                    # Actualizamos la fecha en el objeto en memoria
                                    p['createdTime'] = new_iso_date

                                    # La quitamos de la lista vieja
                                    photos.remove(p)

                                    # La añadimos a la lista nueva (creando claves si faltan)
                                    if new_year not in self.drive_photos_by_date:
                                        self.drive_photos_by_date[new_year] = {}
                                    if new_month not in self.drive_photos_by_date[new_year]:
                                        self.drive_photos_by_date[new_year][new_month] = []

                                    self.drive_photos_by_date[new_year][new_month].append(p)
                                    found = True
                                    break
                            if found: break
                        if found: break

                    count += 1

                except Exception as e:
                    print(f"Error actualizando item {i}: {e}")

            self._set_status(f"Fecha actualizada para {count} fotos. Reorganizando vista...")

            # 3. Recargar la vista completa para reflejar los movimientos
            # Forzamos la limpieza visual y el redibujado
            self.cloud_scroll_area.setUpdatesEnabled(False)
            self._display_cloud_photos()
            self.cloud_scroll_area.setUpdatesEnabled(True)

    # ----------------------------------------------------------------
    # LÓGICA DE MENÚ CONTEXTUAL Y GESTIÓN DE ARCHIVOS
    # ----------------------------------------------------------------

    def _on_context_menu(self, pos, list_widget, is_video, is_hidden_view=False):
        """
        Muestra el menú contextual con opciones para fotos/vídeos.
        INCLUYE: Soporte para Caja Fuerte.
        """
        # 1. BÚSQUEDA GLOBAL DE SELECCIÓN
        # Obtenemos el contenedor padre (el área de scroll) para ver si hay selección múltiple entre meses
        container = list_widget.parent()
        selected_items = []

        if container:
            # Buscamos en todas las listas de meses que haya en el panel
            for lw in container.findChildren(PreviewListWidget):
                selected_items.extend(lw.selectedItems())
        else:
            # Fallback por si algo falla
            selected_items = list_widget.selectedItems()

        if not selected_items:
            return

        menu = QMenu(self)

        if is_hidden_view:
            # --- OPCIONES PARA VISTA DE OCULTOS ---
            action_restore = menu.addAction("Restaurar a la galería")
            action_restore.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_ArrowUp))

            action_delete = menu.addAction("Eliminar del disco (Permanente)")
            action_delete.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_TrashIcon))

            action = menu.exec(list_widget.mapToGlobal(pos))

            if action == action_restore:
                self._restore_selected_media(selected_items, is_video)
            elif action == action_delete:
                self._delete_selected_media(selected_items, is_video, from_hidden_view=True)

        else:
            # --- OPCIONES PARA VISTA NORMAL ---

            # Cabecera informativa
            count = len(selected_items)
            header = menu.addAction(f"{count} elemento(s) seleccionado(s)")
            header.setEnabled(False)
            menu.addSeparator()

            # 1. Cambiar Fecha
            action_date = menu.addAction("Cambiar Fecha (Mover)")
            action_date.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_FileDialogDetailedView))

            # 2. Corregir Ojos Rojos (SOLO PARA FOTOS)
            action_redeye = None
            if not is_video:
                action_redeye = menu.addAction("Corregir Ojos Rojos (Auto)")
                action_redeye.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_DialogApplyButton))

            # 3. Caja Fuerte (NUEVO)
            action_safe = menu.addAction("🔒 Añadir a Caja Fuerte")

            menu.addSeparator()

            # 4. Ocultar y Eliminar
            action_hide = menu.addAction("Ocultar de la vista")

            action_delete = menu.addAction("Eliminar del disco (Permanente)")
            action_delete.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_TrashIcon))

            # Ejecutar menú
            action = menu.exec(list_widget.mapToGlobal(pos))

            # --- MANEJO DE ACCIONES ---
            if action == action_hide:
                self._hide_selected_media(selected_items, is_video)

            elif action == action_delete:
                self._delete_selected_media(selected_items, is_video, from_hidden_view=False)

            elif action == action_date:
                self._change_date_for_selected(selected_items, is_video)

            elif action_redeye and action == action_redeye:
                self._remove_red_eyes_for_selected(selected_items)

            elif action == action_safe:
                # Llamada a la nueva función de encriptación
                self._move_to_safe_box(selected_items, is_video)

    def _remove_red_eye_from_image(self, image_path):
        """Detecta y corrige ojos rojos automáticamente usando OpenCV."""
        try:
            # 1. Leer imagen
            img = cv2.imread(image_path)
            if img is None:
                return False

            img_out = img.copy()

            # 2. Cargar clasificador de ojos pre-entrenado (Haar Cascade)
            # OpenCV suele incluirlo en cv2.data.haarcascades
            eye_cascade_path = cv2.data.haarcascades + 'haarcascade_eye.xml'
            eye_cascade = cv2.CascadeClassifier(eye_cascade_path)

            if eye_cascade.empty():
                print("Error: No se encontró el clasificador de ojos XML.")
                return False

            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

            # 3. Detectar ojos
            eyes = eye_cascade.detectMultiScale(gray, 1.3, 5)

            if len(eyes) == 0:
                return False # No se detectaron ojos

            changed = False

            for (x, y, w, h) in eyes:
                # Extraer la región de interés (ROI) del ojo
                eye_roi = img_out[y:y+h, x:x+w]

                # Separar canales: Blue, Green, Red
                b = eye_roi[:, :, 0]
                g = eye_roi[:, :, 1]
                r = eye_roi[:, :, 2]

                # 4. Crear máscara de "ojo rojo"
                # La rojez suele ser mucho mayor que el verde y el azul combinados
                bg_sum = cv2.add(b, g)
                mask = (r > 150) & (r > bg_sum) # Umbral simple
                mask = mask.astype(np.uint8) * 255

                # Refinar la máscara (llenar huecos)
                mask = cv2.dilate(mask, None, iterations=1)

                # Si hay píxeles rojos detectados
                if np.sum(mask) > 0:
                    changed = True
                    # 5. Corregir: Reemplazar el canal rojo con el promedio de verde y azul
                    mean_bg = cv2.addWeighted(b, 0.5, g, 0.5, 0)

                    # Aplicar solo donde diga la máscara
                    eye_roi_fixed = eye_roi.copy()
                    # Usamos bitwise para mezclar
                    # Donde la mascara es blanca, usamos el promedio cian (mean_bg)
                    # Donde es negra, dejamos el original

                    # Forma numpy rápida:
                    # Convertir máscara a booleano para indexar
                    mask_bool = mask.astype(bool)
                    eye_roi_fixed[:, :, 2][mask_bool] = mean_bg[mask_bool]

                    # Volver a poner el ROI corregido en la imagen principal
                    img_out[y:y+h, x:x+w] = eye_roi_fixed

            if changed:
                # Guardar resultado sobrescribiendo (o podrías guardar copia)
                cv2.imwrite(image_path, img_out)

                # Actualizar fecha de modificación para que se refresquen metadatos si es necesario
                os.utime(image_path, None)
                return True

            return False

        except Exception as e:
            print(f"Error corrigiendo ojos rojos en {image_path}: {e}")
            return False

    def _restore_selected_media(self, items, is_video):
        """Restaura los elementos seleccionados a la vista principal."""
        paths_to_restore = [item.data(Qt.UserRole) for item in items]
        restored_count = 0

        for path in paths_to_restore:
            try:
                year, month = None, None
                target_dict = None

                if is_video:
                    self.db.unhide_video(path)
                    year, month = self.db.get_video_date(path)
                    target_dict = self.videos_by_year_month
                else:
                    self.db.unhide_photo(path)
                    year, month = self.db.get_photo_date(path)
                    target_dict = self.photos_by_year_month

                # Volver a añadir a la estructura de memoria (Diccionario)
                if year and month and target_dict is not None:
                    if year not in target_dict: target_dict[year] = {}
                    if month not in target_dict[year]: target_dict[year][month] = []

                    if path not in target_dict[year][month]:
                        target_dict[year][month].append(path)
                        restored_count += 1

            except Exception as e:
                print(f"Error restaurando {path}: {e}")

        self._set_status(f"{restored_count} elementos restaurados.")

        # Refrescar la vista actual (Ocultos) para que desaparezcan de aquí
        if is_video:
            self._show_hidden_videos_view()
        else:
            self._show_hidden_photos_view()

    def _hide_selected_media(self, items, is_video):
        """Oculta los elementos seleccionados."""
        paths_to_hide = [item.data(Qt.UserRole) for item in items]

        for path in paths_to_hide:
            try:
                if is_video:
                    self.db.hide_video(path)
                    self._remove_from_memory_struct(path, self.videos_by_year_month)
                else:
                    self.db.hide_photo(path)
                    self._remove_from_memory_struct(path, self.photos_by_year_month)
            except Exception as e:
                print(f"Error ocultando {path}: {e}")

        self._set_status(f"{len(items)} elementos ocultados.")
        # Refrescar la vista actual
        if is_video:
            self._display_videos()
        else:
            self._display_photos()

    def _update_file_metadata_on_disk(self, filepath, year_str, month_str):
        """
        Intenta escribir la fecha en los metadatos del archivo.
        1. Para JPG: Escribe en EXIF (DateTimeOriginal).
        2. Para TODO (Videos/RAW/JPG): Cambia la fecha de modificación del archivo.
        """
        try:
            # 1. Preparar la fecha
            # Si el mes es '00' o inválido, ponemos Enero
            m = int(month_str) if month_str.isdigit() and 1 <= int(month_str) <= 12 else 1
            y = int(year_str)

            # Creamos una fecha arbitraria (día 1 a las 12:00)
            new_date = datetime.datetime(y, m, 1, 12, 0, 0)

            # Convertir a timestamp para el sistema de archivos
            timestamp = new_date.timestamp()

            # 2. INTENTAR ESCRIBIR EXIF (Solo JPG/JPEG/TIFF)
            ext = os.path.splitext(filepath)[1].lower()
            if ext in ['.jpg', '.jpeg', '.tiff', '.tif']:
                try:
                    # Formato EXIF: "YYYY:MM:DD HH:MM:SS"
                    exif_date_str = new_date.strftime("%Y:%m:%d %H:%M:%S")

                    # Cargar datos existentes o crear nuevos
                    exif_dict = piexif.load(filepath)

                    # Actualizar DateTimeOriginal, DateTimeDigitized y DateTime
                    exif_dict['Exif'][piexif.ExifIFD.DateTimeOriginal] = exif_date_str
                    exif_dict['Exif'][piexif.ExifIFD.DateTimeDigitized] = exif_date_str
                    exif_dict['0th'][piexif.ImageIFD.DateTime] = exif_date_str

                    exif_bytes = piexif.dump(exif_dict)
                    piexif.insert(exif_bytes, filepath)
                    print(f"EXIF actualizado para: {filepath}")
                except Exception as e_exif:
                    print(f"No se pudo escribir EXIF en {filepath} (posiblemente corrupto o sin cabecera): {e_exif}")

            # 3. CAMBIAR FECHA DEL SISTEMA DE ARCHIVOS (Para Vídeos, RAWs y respaldo de JPG)
            # Esto asegura que al re-escanear, la función 'get_photo_date' o 'get_video_date'
            # lea esta fecha si falla la lectura de metadatos internos.
            os.utime(filepath, (timestamp, timestamp))

        except Exception as e:
            print(f"Error general actualizando fichero físico {filepath}: {e}")

    def _change_date_for_selected(self, items, is_video):
        """
        Cambia la fecha de TODOS los elementos locales seleccionados (Disco + DB).
        """
        if not items: return

        # 1. Abrir diálogo UNA vez
        dialog = DateChangeDialog(self)
        if dialog.exec() == QDialog.Accepted:
            new_year, new_month = dialog.get_data()

            count = 0
            total = len(items)
            paths_to_update = [item.data(Qt.UserRole) for item in items]

            self._set_status(f"Procesando cambio de fecha para {total} archivos...")

            # 2. Iterar y aplicar cambios
            for i, path in enumerate(paths_to_update):
                try:
                    # A) Actualizar archivo FÍSICO (Metadatos + Fecha Modificación)
                    self._update_file_metadata_on_disk(path, new_year, new_month)

                    # B) Actualizar Base de Datos y Memoria
                    if is_video:
                        self.db.update_video_date(path, new_year, new_month)

                        # Mover en memoria (Vídeos)
                        self._remove_from_memory_struct(path, self.videos_by_year_month)
                        if new_year not in self.videos_by_year_month:
                            self.videos_by_year_month[new_year] = {}
                        if new_month not in self.videos_by_year_month[new_year]:
                            self.videos_by_year_month[new_year][new_month] = []
                        self.videos_by_year_month[new_year][new_month].append(path)

                    else:
                        self.db.update_photo_date(path, new_year, new_month)

                        # Mover en memoria (Fotos)
                        self._remove_from_memory_struct(path, self.photos_by_year_month)
                        if new_year not in self.photos_by_year_month:
                            self.photos_by_year_month[new_year] = {}
                        if new_month not in self.photos_by_year_month[new_year]:
                            self.photos_by_year_month[new_year][new_month] = []
                        self.photos_by_year_month[new_year][new_month].append(path)

                    count += 1

                    # Actualizar estado cada 10 fotos para no saturar
                    if i % 10 == 0:
                        self._set_status(f"Actualizando fecha ({i+1}/{total})...")

                except Exception as e:
                    print(f"Error actualizando fecha de {path}: {e}")

            self._set_status(f"Fecha cambiada correctamente en {count} archivos. Refrescando...")

            # 3. Refrescar la vista correspondiente
            if is_video:
                self.video_scroll_area.setUpdatesEnabled(False)
                self._display_videos()
                self.video_scroll_area.setUpdatesEnabled(True)
            else:
                self.scroll_area.setUpdatesEnabled(False)
                self._display_photos()
                self.scroll_area.setUpdatesEnabled(True)

    def _delete_selected_media(self, items, is_video, from_hidden_view=False):
        """Elimina físicamente los archivos y de la BD."""
        count = len(items)
        confirm = QMessageBox.question(
            self,
            "Confirmar eliminación",
            f"¿Estás seguro de que quieres eliminar {count} archivo(s) de tu DISCO DURO?\nEsta acción no se puede deshacer.",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
        )

        if confirm != QMessageBox.StandardButton.Yes:
            return

        paths_to_delete = [item.data(Qt.UserRole) for item in items]
        deleted_count = 0

        for path in paths_to_delete:
            try:
                # 1. Borrar del disco
                if os.path.exists(path):
                    os.remove(path)

                # 2. Borrar de la BD
                if is_video:
                    self.db.delete_video_permanently(path)
                    # Solo borrar de memoria si NO estaba oculta (si estaba oculta, ya no estaba en memoria)
                    if not from_hidden_view:
                        self._remove_from_memory_struct(path, self.videos_by_year_month)
                else:
                    self.db.delete_photo_permanently(path)
                    if not from_hidden_view:
                        self._remove_from_memory_struct(path, self.photos_by_year_month)

                deleted_count += 1
            except Exception as e:
                print(f"Error eliminando {path}: {e}")
                self._set_status(f"Error eliminando: {Path(path).name}")

        self._set_status(f"{deleted_count} archivos eliminados permanentemente.")

        # Refrescar la vista correspondiente
        if from_hidden_view:
            if is_video: self._show_hidden_videos_view()
            else: self._show_hidden_photos_view()
        else:
            if is_video: self._display_videos()
            else: self._display_photos()

    def _remove_from_memory_struct(self, path, struct):
        """Ayuda a eliminar un path del diccionario year/month."""
        for year, months in struct.items():
            for month, files in months.items():
                if path in files:
                    files.remove(path)
                    # Limpieza si quedan vacíos
                    if not files:
                        del struct[year][month]
                    if not struct[year]:
                        del struct[year]
                    return

    # ------------------------------------------------------------------
    # NUEVA LÓGICA DE SINCRONIZACIÓN SCROLL -> ÁRBOL
    # ------------------------------------------------------------------

    def _on_photo_scroll_changed(self):
        """Sincroniza el árbol de fechas de fotos al hacer scroll."""
        self._sync_tree_from_scroll(
            self.scroll_area,
            self.photo_group_widgets,
            self.date_tree_widget
        )

    def _on_video_scroll_changed(self):
        """Sincroniza el árbol de fechas de vídeos al hacer scroll."""
        self._sync_tree_from_scroll(
            self.video_scroll_area,
            self.video_group_widgets,
            self.video_date_tree_widget
        )

    def _on_cloud_scroll_changed(self):
        """Sincroniza el árbol de fechas de la Nube al hacer scroll."""
        self._sync_tree_from_scroll(
            self.cloud_scroll_area,
            self.cloud_group_widgets,
            self.cloud_date_tree
        )

    def _sync_tree_from_scroll(self, scroll_area, group_widgets_dict, tree_widget):
        """
        Calcula qué etiqueta (Año/Mes) está visible en la parte superior
        y selecciona el item correspondiente en el árbol.
        """
        if not group_widgets_dict: return

        # Obtenemos la posición vertical actual del scroll
        viewport_top = scroll_area.verticalScrollBar().value()

        best_key = None
        best_y = -1

        # Buscamos el widget (etiqueta de año o mes) que esté más abajo
        # pero que aún esté por encima (o rozando) la línea superior de la vista.
        # Le damos un margen de 50px para que la selección cambie justo cuando el título llega arriba.

        container_widget = scroll_area.widget()
        if not container_widget: return

        # Iteramos sobre los widgets registrados (etiquetas de texto Año/Mes)
        for key, widget in group_widgets_dict.items():
            try:
                if not widget.isVisible(): continue

                # Posición Y del widget dentro del área total
                y = widget.y()

                # Si el widget está por encima de mi vista actual (+ margen)
                if y <= viewport_top + 80:
                    # Me quedo con el que tenga la Y más alta (el que está más cerca de mi vista actual)
                    if y > best_y:
                        best_y = y
                        best_key = key
            except RuntimeError:
                pass # El widget pudo haber sido borrado

        if best_key:
            # Ahora buscamos ese item en el árbol para seleccionarlo
            # Las claves son "YYYY" o "YYYY-MM"
            self._select_tree_item_by_key(tree_widget, best_key)

    def _select_tree_item_by_key(self, tree_widget, key):
        """Selecciona un item en el árbol de forma inteligente (soporta Texto y Tuplas)."""
        tree_widget.blockSignals(True)

        try:
            # Descomponemos la clave (Ej: "2023-05")
            parts = key.split('-')
            year = parts[0]
            month = parts[1] if len(parts) > 1 else None

            # 1. Buscar el AÑO (Primer nivel)
            year_item = None
            for i in range(tree_widget.topLevelItemCount()):
                item = tree_widget.topLevelItem(i)
                # Comparamos como string por seguridad
                if str(item.text(0)) == str(year):
                    year_item = item
                    break

            target_item = None

            if year_item:
                if month:
                    # 2. Buscar el MES (Hijo)
                    # Aquí está la mejora: comprobamos el dato de forma flexible
                    for i in range(year_item.childCount()):
                        child = year_item.child(i)
                        data = child.data(0, Qt.UserRole)

                        is_match = False

                        # CASO A: El dato es una Tupla o Lista ['2023', '05'] (Fotos/Videos/Nube nueva)
                        if isinstance(data, (list, tuple)) and len(data) > 1:
                            if str(data[1]) == str(month):
                                is_match = True

                        # CASO B: El dato es Texto "2023-05" (Nube antigua)
                        elif isinstance(data, str):
                            # Comprobamos si termina en "-05" o es igual a "05"
                            if data == month or data.endswith(f"-{month}"):
                                is_match = True

                        if is_match:
                            target_item = child
                            break

                    # Si buscábamos un mes y no lo encontramos, nos quedamos en el año
                    if not target_item:
                        target_item = year_item
                else:
                    # Si la clave solo era el año
                    target_item = year_item

            if target_item:
                tree_widget.setCurrentItem(target_item)
                tree_widget.scrollToItem(target_item)

        finally:
            tree_widget.blockSignals(False)

    @Slot(QTreeWidgetItem, QTreeWidgetItem)
    def _scroll_to_item(self, current_item: QTreeWidgetItem, previous_item: QTreeWidgetItem):
        """Desplazarse al grupo de FOTOS. Versión blindada contra errores C++."""
        if not current_item: return

        # --- PASO 1: EXTRAER DATOS ---
        user_data = current_item.data(0, Qt.UserRole)

        if user_data == "HIDDEN_SECTION":
            self._show_hidden_photos_view()
            return

        target_key = ""
        if current_item.parent():
            year, month = user_data
            target_key = f"{year}-{month}"
        else:
            target_key = current_item.text(0)

        # --- PASO 2: OBTENER WIDGET ---
        target_widget = self.photo_group_widgets.get(target_key)

        # --- PASO 3: VALIDACIÓN DE VIDA ---
        is_zombie = False
        if target_widget:
            try:
                _ = target_widget.isVisible()
            except RuntimeError:
                is_zombie = True

        # Si no existe o es un zombie, regeneramos la vista
        if not target_widget or is_zombie:
            self._display_photos()
            target_widget = self.photo_group_widgets.get(target_key)

        # --- PASO 4: SCROLL SEGURO ---
        if target_widget:
            try:
                self.scroll_area.ensureWidgetVisible(target_widget, 50, 50)
                QTimer.singleShot(200, self._load_main_visible_thumbnails)
            except RuntimeError:
                print("Aviso: No se pudo hacer scroll al widget de foto.")

    @Slot(QTreeWidgetItem, QTreeWidgetItem)
    def _scroll_to_video_item(self, current_item: QTreeWidgetItem, previous_item: QTreeWidgetItem):
        """Desplazarse al grupo de VÍDEOS. Versión blindada contra errores C++."""
        if not current_item: return

        # --- PASO 1: EXTRAER DATOS ---
        user_data = current_item.data(0, Qt.UserRole)

        if user_data == "HIDDEN_SECTION":
            self._show_hidden_videos_view()
            return

        target_key = ""
        if current_item.parent():
            year, month = user_data
            target_key = f"{year}-{month}"
        else:
            target_key = current_item.text(0)

        # --- PASO 2: OBTENER WIDGET ---
        target_widget = self.video_group_widgets.get(target_key)

        # --- PASO 3: VALIDACIÓN DE VIDA ---
        is_zombie = False
        if target_widget:
            try:
                _ = target_widget.isVisible()
            except RuntimeError:
                is_zombie = True

        if not target_widget or is_zombie:
            self._display_videos()
            target_widget = self.video_group_widgets.get(target_key)

        # --- PASO 4: SCROLL SEGURO ---
        if target_widget:
            try:
                self.video_scroll_area.ensureWidgetVisible(target_widget, 50, 50)
                QTimer.singleShot(200, self._load_visible_video_thumbnails)
            except RuntimeError:
                print("Aviso: No se pudo hacer scroll al widget de vídeo.")

    @Slot(dict)
    def _handle_search_finished(self, new_photos_by_year_month):
        """Se llama cuando el PhotoFinderWorker termina."""
        self.select_dir_button.setEnabled(True)

        # 1. OPTIMIZACIÓN: Si los datos no han cambiado, NO redibujamos nada.
        # Esto evita parpadeos por falsas alarmas del vigilante.
        if self.photos_by_year_month == new_photos_by_year_month:
            # print("Escaneo completado: Sin cambios detectados.")
            # Aún así lanzamos el escáner de caras por si acaso
            self._start_face_scan()
            return

        # Si hay cambios reales, procedemos:
        self.photos_by_year_month = new_photos_by_year_month

        num_fotos = sum(len(photos) for months in self.photos_by_year_month.values() for photos in months.values())
        self._set_status(f"Actualizando biblioteca... {num_fotos} fotos.")

        # 2. TRUCO VISUAL: Congelar la interfaz para evitar el parpadeo blanco
        self.scroll_area.setUpdatesEnabled(False)

        # 3. Guardar posición del scroll
        current_scroll = self.scroll_area.verticalScrollBar().value()

        # Redibujar
        self._display_photos()

        # 4. Restaurar scroll y descongelar
        self.scroll_area.verticalScrollBar().setValue(current_scroll)
        self.scroll_area.setUpdatesEnabled(True)

        self._start_face_scan()

    @Slot(dict)
    def _handle_video_search_finished(self, new_videos_by_year_month):
        """Se llama cuando el VideoFinderWorker termina."""
        self.select_dir_button.setEnabled(True)

        # 1. Verificar cambios
        if self.videos_by_year_month == new_videos_by_year_month:
            # print("Escaneo de vídeos completado: Sin cambios.")
            return

        self.videos_by_year_month = new_videos_by_year_month

        num_videos = sum(len(videos) for months in self.videos_by_year_month.values() for videos in months.values())
        self._set_status(f"Actualizando biblioteca... {num_videos} vídeos.")

        # 2. Congelar
        self.video_scroll_area.setUpdatesEnabled(False)

        # 3. Guardar Scroll
        current_scroll = self.video_scroll_area.verticalScrollBar().value()

        # Redibujar
        self._display_videos()

        # 4. Restaurar y Descongelar
        self.video_scroll_area.verticalScrollBar().setValue(current_scroll)
        self.video_scroll_area.setUpdatesEnabled(True)

    def _set_status(self, message):
        # Usamos la barra de estado nativa de la ventana (visible en todas las pestañas)
        self.statusBar().showMessage(f"Estado: {message}")

    # --- NUEVO MÉTODO PARA SUAVIZAR SCROLL ---
    def _debounced_thumbnail_load(self):
        """Espera a que el usuario deje de hacer scroll antes de cargar imágenes."""
        if hasattr(self, '_thumb_timer') and self._thumb_timer.isActive():
            self._thumb_timer.stop()

        self._thumb_timer = QTimer()
        self._thumb_timer.setSingleShot(True)
        # Esperar 150ms de quietud antes de cargar. Ajusta si lo notas lento.
        self._thumb_timer.setInterval(150)
        self._thumb_timer.timeout.connect(self._load_main_visible_thumbnails)
        self._thumb_timer.start()

    def _load_main_visible_thumbnails(self):
        """Carga miniaturas de FOTOS visibles (Refactorizado para QListWidget)."""
        viewport = self.scroll_area.viewport()
        preload_rect = viewport.rect().adjusted(0, -PRELOAD_MARGIN_PX, 0, PRELOAD_MARGIN_PX)

        # Iterar sobre los QListWidgets en el área de scroll de fotos
        for list_widget in self.scroll_area.widget().findChildren(PreviewListWidget):

            # Comprobar si el QListWidget está visible
            list_widget_pos = list_widget.mapTo(viewport, list_widget.rect().topLeft())
            list_widget_rect_in_viewport = list_widget.rect().translated(list_widget_pos)

            if preload_rect.intersects(list_widget_rect_in_viewport):
                # Si el widget es visible, comprobar sus items
                for i in range(list_widget.count()):
                    item = list_widget.item(i)
                    load_status = item.data(Qt.UserRole + 1)

                    if load_status == "not_loaded":
                        original_path = item.data(Qt.UserRole)
                        if original_path:
                            item.setData(Qt.UserRole + 1, "loading") # Marcar como "cargando"
                            item.setText("Cargando...") # Asegurarse de que el texto de carga está

                            loader = ThumbnailLoader(original_path, self.thumb_signals)
                            self.threadpool.start(loader)

    def _load_visible_video_thumbnails(self):
        """Carga miniaturas de VÍDEOS visibles (Refactorizado para QListWidget)."""
        viewport = self.video_scroll_area.viewport()
        preload_rect = viewport.rect().adjusted(0, -PRELOAD_MARGIN_PX, 0, PRELOAD_MARGIN_PX)

        # Iterar sobre los QListWidgets en el área de scroll de vídeos
        for list_widget in self.video_scroll_area.widget().findChildren(PreviewListWidget):

            # Comprobar si el QListWidget está visible
            list_widget_pos = list_widget.mapTo(viewport, list_widget.rect().topLeft())
            list_widget_rect_in_viewport = list_widget.rect().translated(list_widget_pos)

            if preload_rect.intersects(list_widget_rect_in_viewport):
                # Si el widget es visible, comprobar sus items
                for i in range(list_widget.count()):
                    item = list_widget.item(i)
                    load_status = item.data(Qt.UserRole + 1)

                    if load_status == "not_loaded":
                        original_path = item.data(Qt.UserRole)
                        if original_path:
                            item.setData(Qt.UserRole + 1, "loading") # Marcar como "cargando"
                            item.setText("Cargando...")

                            loader = VideoThumbnailLoader(original_path, self.thumb_signals)
                            self.threadpool.start(loader)

    @Slot()
    def _load_person_visible_thumbnails(self):
        # Esta función (Pestaña Personas) no ha sido refactorizada,
        # así que su lógica original de "findChildren(ZoomableClickableLabel)"
        # sigue siendo correcta.
        viewport = self.person_photo_scroll_area.viewport()
        preload_rect = viewport.rect().adjusted(0, -PRELOAD_MARGIN_PX, 0, PRELOAD_MARGIN_PX)
        person_photo_widget = self.person_photo_scroll_area.widget()
        if not person_photo_widget:
            return
        for photo_label in person_photo_widget.findChildren(ZoomableClickableLabel):
            original_path = photo_label.property("original_path")
            is_loaded = photo_label.property("loaded")
            if original_path and is_loaded is False:
                label_pos = photo_label.mapTo(viewport, photo_label.rect().topLeft())
                label_rect_in_viewport = photo_label.rect().translated(label_pos)
                if preload_rect.intersects(label_rect_in_viewport):
                    photo_label.setProperty("loaded", None)
                    loader = ThumbnailLoader(original_path, self.thumb_signals)
                    self.threadpool.start(loader)

    @Slot(str, QPixmap)
    def _update_thumbnail(self, original_path, pixmap):
        # ---------------------------------------------------------
        # 1. BLOQUE PARA FOTOS LOCALES
        # ---------------------------------------------------------
        if original_path in self.photo_list_widget_items:
            item = self.photo_list_widget_items[original_path]
            scaled_pixmap = pixmap.scaled(
                self.current_thumbnail_size,
                self.current_thumbnail_size,
                Qt.KeepAspectRatio,
                Qt.SmoothTransformation
            )
            item.setIcon(QIcon(scaled_pixmap))
            item.setSizeHint(scaled_pixmap.size()) # <--- Esto ajusta el tamaño en local
            item.setText("")
            item.setData(Qt.UserRole + 1, "loaded")
            return

        # ---------------------------------------------------------
        # 2. BLOQUE PARA VÍDEOS
        # ---------------------------------------------------------
        if original_path in self.video_list_widget_items:
            item = self.video_list_widget_items[original_path]
            scaled_pixmap = pixmap.scaled(
                self.current_thumbnail_size,
                self.current_thumbnail_size,
                Qt.KeepAspectRatio,
                Qt.SmoothTransformation
            )
            item.setIcon(QIcon(scaled_pixmap))
            item.setSizeHint(scaled_pixmap.size())
            item.setText("")
            item.setData(Qt.UserRole + 1, "loaded")
            return

        # ---------------------------------------------------------
        # 3. BLOQUE PARA DRIVE (CORREGIDO PARA AJUSTAR TAMAÑO)
        # ---------------------------------------------------------
        if self.cloud_scroll_area.widget():
            for list_widget in self.cloud_scroll_area.widget().findChildren(PreviewListWidget):
                if not list_widget.isVisible(): continue

                for i in range(list_widget.count()):
                    item = list_widget.item(i)
                    data = item.data(Qt.UserRole)

                    if data and data.get('id') == original_path:
                        # Escalamos manteniendo aspecto
                        scaled = pixmap.scaled(128, 128, Qt.KeepAspectRatio, Qt.SmoothTransformation)
                        item.setIcon(QIcon(scaled))

                        # --- ¡ESTA ES LA LÍNEA QUE FALTABA! ---
                        # Ajusta la celda al tamaño real de la imagen (ej: 128x90)
                        # eliminando el espacio vacío sobrante.
                        item.setSizeHint(scaled.size())
                        # --------------------------------------

                        item.setText("")
                        item.setData(Qt.UserRole + 1, "loaded")
                        return

        # ---------------------------------------------------------
        # 4. BLOQUE PARA PERSONAS
        # ---------------------------------------------------------
        def update_in_container(container_widget):
            if not container_widget: return
            for label in container_widget.findChildren(ZoomableClickableLabel):
                if label.property("original_path") == original_path and label.property("loaded") is not True:
                    label.setPixmap(pixmap.scaled(THUMBNAIL_SIZE[0], THUMBNAIL_SIZE[1], Qt.KeepAspectRatio, Qt.SmoothTransformation))
                    label.setText("")
                    label.setProperty("loaded", True)

        update_in_container(self.person_photo_scroll_area.widget())

    # -------------------------------------------------------------------------
    # GESTIÓN DE VISTA PREVIA EN LA NUBE
    # -------------------------------------------------------------------------

    @Slot(object)
    def _on_drive_preview_requested(self, file_data):
        """
        Maneja la solicitud de vista previa desde la nube.
        """
        if not isinstance(file_data, dict): return
        file_id = file_data.get('id')
        name = file_data.get('name')
        if not file_id or not name: return

        self._set_status(f"Vista previa: Bajando {name}...")

        # --- NUEVA RUTA UNIFICADA ---
        base_dir = os.path.dirname(os.path.abspath(__file__))
        # visagevault_cache/drive_cache
        temp_dir = os.path.join(base_dir, "visagevault_cache", "drive_cache")
        # ----------------------------

        if not os.path.exists(temp_dir): os.makedirs(temp_dir)
        local_path = os.path.join(temp_dir, name)

        # Comprobar Caché
        if os.path.exists(local_path):
            if os.path.getsize(local_path) == 0:
                try: os.remove(local_path)
                except: pass
            else:
                self._open_preview_dialog(local_path)
                self._set_status("Vista previa (desde caché).")
                return

        # Descarga en hilo seguro
        threading.Thread(target=self._download_thread_safe, args=(file_id, local_path), daemon=True).start()

    def _download_thread_safe(self, file_id, local_path):
        """Descarga el archivo sin bloquear la interfaz."""
        try:
            manager = DriveManager()
            manager.download_file(file_id, local_path)

            # Volver al hilo principal para abrir la ventana
            QTimer.singleShot(0, lambda: self._finish_cloud_preview(local_path))
        except Exception as e:
            print(f"Error descarga preview: {e}")
            QTimer.singleShot(0, lambda: self._set_status("Error al descargar imagen."))
            # Borrar archivo parcial si falló
            if os.path.exists(local_path):
                try: os.remove(local_path)
                except: pass

    def _finish_cloud_preview(self, local_path):
        """Se ejecuta en el hilo principal cuando la descarga termina."""
        self._set_status("Imagen descargada. Abriendo visor...")
        self._open_preview_dialog(local_path)

    @Slot(QListWidgetItem)
    def _on_drive_item_double_clicked(self, item):
        file_data = item.data(Qt.UserRole)
        if not file_data: return

        file_id = file_data['id']
        name = file_data['name']

        self._set_status(f"Descargando {name} de la nube...")

        # Crear carpeta temporal si no existe
        temp_dir = os.path.join(self.root_cache, "drive_cache")
        if not os.path.exists(temp_dir): os.makedirs(temp_dir)

        local_path = os.path.join(temp_dir, name)

        # Descargar en hilo para no congelar
        threading.Thread(target=self._download_and_show, args=(file_id, local_path), daemon=True).start()

    def _download_and_show(self, file_id, local_path):
        try:
            # --- CORRECCIÓN CRÍTICA DE SEGURIDAD DE HILOS ---
            local_manager = DriveManager()
            local_manager.download_file(file_id, local_path)

            # Volver a UI para abrir el visor
            QTimer.singleShot(0, lambda: self._open_photo_detail(local_path))
            QTimer.singleShot(0, lambda: self._set_status("Descarga completada."))
        except Exception as e:
            print(f"Error descarga: {e}")

    @Slot(str)
    def _handle_thumbnail_failed(self, original_path: str):

        # REFACTOR: Comprobar si es un item de QListWidget de FOTOS
        if original_path in self.photo_list_widget_items:
            item = self.photo_list_widget_items[original_path]
            icon = self.style().standardIcon(QStyle.StandardPixmap.SP_FileIcon) # Icono genérico
            item.setIcon(icon)
            item.setText("") # Quitar "Cargando..."
            item.setData(Qt.UserRole + 1, "failed") # Marcar como fallido
            return

        # REFACTOR: Comprobar si es un item de QListWidget de VÍDEOS
        if original_path in self.video_list_widget_items:
            item = self.video_list_widget_items[original_path]
            icon = self.style().standardIcon(QStyle.StandardPixmap.SP_FileIcon) # Icono genérico
            item.setIcon(icon)
            item.setText("") # Quitar "Cargando..."
            item.setData(Qt.UserRole + 1, "failed") # Marcar como fallido
            return

        # Lógica original (para la pestaña Personas)
        def fail_in_container(container_widget):
            if not container_widget:
                return
            for label in container_widget.findChildren(ZoomableClickableLabel):
                if label.property("original_path") == original_path and label.property("loaded") is not True:
                    label.setText("Error al cargar.")
                    label.setProperty("loaded", True)

        fail_in_container(self.person_photo_scroll_area.widget())


    @Slot()
    def _save_photo_splitter_state(self):
        """Guarda las posiciones del splitter de FOTOS en la configuración."""
        sizes = self.main_splitter.sizes()
        config_data = config_manager.load_config()
        config_data['photo_splitter_sizes'] = sizes
        config_manager.save_config(config_data)

    @Slot()
    def _save_video_splitter_state(self):
        """Guarda las posiciones del splitter de VÍDEOS en la configuración."""
        sizes = self.video_splitter.sizes()
        config_data = config_manager.load_config()
        config_data['video_splitter_sizes'] = sizes
        config_manager.save_config(config_data)

    def _load_photo_splitter_state(self):
        """Carga posiciones y configura prioridades de estiramiento (Fotos)."""
        # 1. Configurar prioridades: Centro (1) se estira, Lados (0) fijos.
        self.main_splitter.setStretchFactor(0, 0) # Árbol
        self.main_splitter.setStretchFactor(1, 1) # Fotos (Prioridad)
        self.main_splitter.setStretchFactor(2, 0) # Fechas

        config_data = config_manager.load_config()
        sizes = config_data.get('photo_splitter_sizes')
        min_right_width = 180

        # Migración de config antigua
        if sizes and len(sizes) == 2:
            sizes.insert(0, 0)

        if not sizes or len(sizes) != 3:
            w = self.width()
            sizes = [0, int(w * 0.8), int(w * 0.2)]

        # Proteger ancho mínimo panel derecho
        if sizes[2] < min_right_width:
            diff = min_right_width - sizes[2]
            sizes[2] = min_right_width
            if sizes[1] > diff:
                sizes[1] -= diff

        self.main_splitter.setSizes(sizes)

    def _load_video_splitter_state(self):
        """Carga posiciones y configura prioridades de estiramiento (Vídeos)."""
        # 1. Configurar prioridades
        self.video_splitter.setStretchFactor(0, 0)
        self.video_splitter.setStretchFactor(1, 1) # Vídeos (Prioridad)
        self.video_splitter.setStretchFactor(2, 0)

        config_data = config_manager.load_config()
        sizes = config_data.get('video_splitter_sizes')
        min_right_width = 180

        # Migración
        if sizes and len(sizes) == 2:
            sizes.insert(0, 0)

        if not sizes or len(sizes) != 3:
            w = self.width()
            sizes = [0, int(w * 0.8), int(w * 0.2)]

        if sizes[2] < min_right_width:
            diff = min_right_width - sizes[2]
            sizes[2] = min_right_width
            if sizes[1] > diff:
                sizes[1] -= diff

        self.video_splitter.setSizes(sizes)

    def resizeEvent(self, event):
        self.resize_timer.start()
        super().resizeEvent(event)

    @Slot()
    def _handle_resize_timeout(self):
        # Si no hay fotos O vídeos cargados, no hagas nada
        if not self.photos_by_year_month and not self.videos_by_year_month:
            return

        # print(f"Redibujando layout para el nuevo ancho.")
        # Re-dibujar AMBAS pestañas
        if self.photos_by_year_month:
            self._display_photos()
        if self.videos_by_year_month:
            self._display_videos()
        self._reflow_faces()
        # Ajustar geometría de la nube sin recargar las imágenes

    @Slot(str)
    def _open_photo_detail(self, original_path):
        """Abre la ventana de detalle de la foto."""
        self._set_status(f"Abriendo detalle para: {Path(original_path).name}")
        dialog = PhotoDetailDialog(original_path, self.db, self)
        dialog.metadata_changed.connect(self._handle_photo_date_changed)
        dialog.exec()
        self._set_status("Detalle cerrado.")

    @Slot(QListWidgetItem)
    def _on_photo_item_double_clicked(self, item: QListWidgetItem):
        """Se llama cuando se hace doble clic en un item de QListWidget de fotos."""
        original_path = item.data(Qt.UserRole)
        if original_path:
            self._open_photo_detail(original_path)

    @Slot(QListWidgetItem)
    def _on_video_item_double_clicked(self, item: QListWidgetItem):
        """Se llama cuando se hace doble clic en un item de QListWidget de vídeos."""
        original_path = item.data(Qt.UserRole)
        if original_path:
            self._open_video_player(original_path)

    # --- ¡NUEVO SLOT PARA VISTA PREVIA! ---
    @Slot(str)
    def _open_preview_dialog(self, original_path: str):
        """
        Abre la vista previa (ImagePreviewDialog) para una imagen,
        manejando formatos estándar y RAW.
        """
        if ImagePreviewDialog.is_showing:
            return
        if not original_path:
            return

        pixmap = QPixmap() # Empezar con un pixmap vacío

        # Definir extensiones RAW (deben coincidir con las de los otros archivos)
        RAW_EXTENSIONS = ('.nef', '.cr2', '.cr3', '.crw', '.arw', '.srf', '.orf', '.rw2', '.raf', '.pef', '.dng', '.raw')
        file_suffix = Path(original_path).suffix.lower()

        try:
            if file_suffix in RAW_EXTENSIONS:
                # 1. Usar rawpy para leer el archivo RAW
                with rawpy.imread(original_path) as raw:
                    rgb_array = raw.postprocess()

                # 2. Convertir el array de numpy a QImage
                height, width, channel = rgb_array.shape
                bytes_per_line = 3 * width
                q_image = QImage(rgb_array.data, width, height, bytes_per_line, QImage.Format.Format_RGB888).copy()

                # 3. Convertir QImage a QPixmap
                pixmap = QPixmap.fromImage(q_image)

            else:
                # 4. Lógica original para JPG, PNG, etc.
                pixmap = QPixmap(original_path)

            if pixmap.isNull():
                print(f"Error cargando pixmap para vista previa: {original_path}")
                return

            # Lanzar el diálogo
            preview_dialog = ImagePreviewDialog(pixmap, self)
            preview_dialog.show_with_animation()

        except Exception as e:
            print(f"Error al cargar vista previa (Doble Clic): {e}")

    @Slot()
    def _handle_photo_date_changed(self, photo_path: str, new_year: str, new_month: str):
        self._set_status("Metadatos de foto cambiados. Reconstruyendo vista...")
        path_found_and_removed = False
        for year, months in self.photos_by_year_month.items():
            for month, photos in months.items():
                if photo_path in photos:
                    photos.remove(photo_path)
                    path_found_and_removed = True
                    if not photos:
                        del self.photos_by_year_month[year][month]
                    if not self.photos_by_year_month[year]:
                        del self.photos_by_year_month[year]
                    break
            if path_found_and_removed:
                break
        if new_year not in self.photos_by_year_month:
            self.photos_by_year_month[new_year] = {}
        if new_month not in self.photos_by_year_month[new_year]:
            self.photos_by_year_month[new_year][new_month] = []
        self.photos_by_year_month[new_year][new_month].append(photo_path)
        self._display_photos()

    @Slot(str)
    def _open_video_player(self, video_path):
        """
        Abre el archivo de vídeo dado con el reproductor por defecto del sistema.
        """
        try:
            file_url = QUrl.fromLocalFile(video_path)
            if not QDesktopServices.openUrl(file_url):
                self._set_status(f"Error: No se pudo abrir {video_path}. ¿Hay un reproductor de vídeo configurado?")
            else:
                self._set_status(f"Abriendo {Path(video_path).name}...")
        except Exception as e:
            print(f"Error al intentar abrir el vídeo: {e}")
            self._set_status(f"Error: {e}")

    def _reflow_faces(self):
        """
        Reorganiza visualmente todas las caras para ajustarse al ancho actual de la ventana.
        Corrige la 'columna vertical' creada durante la precarga oculta.
        """
        # 1. Calcular cuántas columnas caben REALMENTE ahora
        viewport_width = self.face_scroll_area.viewport().width() - 30
        if viewport_width <= 0: return

        new_num_cols = max(1, viewport_width // 110)

        # 2. Extraer todos los widgets de caras existentes
        faces = []
        # Usamos un bucle para sacar todo del layout limpiamente
        while self.unknown_faces_layout.count() > 0:
            item = self.unknown_faces_layout.takeAt(0)
            w = item.widget()
            if w:
                # Solo guardamos si es una cara válida (evitamos etiquetas de error antiguas)
                if isinstance(w, CircularFaceLabel) or w.property("face_id"):
                    faces.append(w)
                else:
                    w.deleteLater() # Borrar mensajes viejos tipo "Cargando..."

        # 3. Volver a insertarlos en el orden correcto (Izquierda -> Derecha)
        for i, face_widget in enumerate(faces):
            row = i // new_num_cols
            col = i % new_num_cols
            self.unknown_faces_layout.addWidget(face_widget, row, col, Qt.AlignTop)

        # 4. Actualizar el contador global para que las NUEVAS caras sigan desde aquí
        self.current_face_count = len(faces)

    @Slot(int)
    def _on_tab_changed(self, index):
        self.threadpool.clear()
        tab_name = self.tab_widget.tabText(index)

        if tab_name == "Personas":
            self._set_status("Mostrando caras...")

            if self.face_loading_label:
                self.face_loading_label.deleteLater()
                self.face_loading_label = None

            # --- CORRECCIÓN: REORGANIZAR REJILLA ---
            # Arregla el desorden causado por la precarga en segundo plano
            self._reflow_faces()
            # ---------------------------------------

            current_item = self.people_tree_widget.currentItem()
            if current_item and current_item.data(0, Qt.UserRole) == -2:
                 pass
            else:
                 self._load_existing_faces_async()

            if self.face_scan_thread and self.face_scan_thread.isRunning():
                 self._set_status("Mostrando caras. Escaneo sigue en segundo plano...")

        elif tab_name == "Caja Fuerte":
            if hasattr(self, 'unlocked_widget') and self.unlocked_widget.isVisible():
                self._load_safe_content()

        elif tab_name == "Nube":
            QTimer.singleShot(100, self._load_visible_cloud_thumbnails)

    def _load_people_list(self):
        self.people_tree_widget.clear()
        unknown_item = QTreeWidgetItem(self.people_tree_widget, ["Caras Sin Asignar"])
        unknown_item.setData(0, Qt.UserRole, -1)
        deleted_item = QTreeWidgetItem(self.people_tree_widget, ["Caras Eliminadas"])
        deleted_item.setData(0, Qt.UserRole, -2)
        people = self.db.get_all_people()
        if people:
            people_root_item = QTreeWidgetItem(self.people_tree_widget, ["Personas"])
            for person_row in people:
                person_id = person_row['id']
                person_name = person_row['name']
                person_item = QTreeWidgetItem(people_root_item, [person_name])
                person_item.setData(0, Qt.UserRole, person_id)
            people_root_item.setExpanded(True)
        self.people_tree_widget.setCurrentItem(unknown_item)

    def _populate_face_grid_async(self, face_list: list, is_deleted_view: bool = False, append: bool = False):
        """Rellena la rejilla de caras de forma robusta e incremental."""

        if not append:
            while self.unknown_faces_layout.count() > 0:
                item = self.unknown_faces_layout.takeAt(0)
                if item.widget(): item.widget().deleteLater()
            self.current_face_count = 0

            if not face_list:
                placeholder = QLabel("No se han encontrado caras.")
                placeholder.setAlignment(Qt.AlignCenter)
                self.unknown_faces_layout.addWidget(placeholder, 0, 0, Qt.AlignCenter)
                return

        if append and not face_list:
            return

        if self.unknown_faces_layout.count() == 1:
            item = self.unknown_faces_layout.itemAt(0)
            widget = item.widget()
            if isinstance(widget, QLabel) and not isinstance(widget, CircularFaceLabel):
                 widget.deleteLater()
                 self.current_face_count = 0

        # --- CORRECCIÓN DE GEOMETRÍA DE PRECARGA ---
        # Obtenemos el ancho real del área de scroll
        viewport_width = self.left_people_stack.width() - 30

        # Si la pestaña está oculta (precarga), el ancho suele ser irrelevante (ej: 100px).
        # En ese caso, usamos el ancho de la ventana principal menos el panel lateral (aprox 280px)
        if viewport_width < 300:
            viewport_width = max(400, self.width() - 350)
        # -------------------------------------------

        num_cols = max(1, viewport_width // 110)
        start_index = self.unknown_faces_layout.count()

        for i, face_row in enumerate(face_list):
            face_id = face_row['id']

            face_widget = CircularFaceLabel(QPixmap())
            face_widget.setText("Cargando...")
            face_widget.setStyleSheet("color: gray; font-size: 10px;")

            face_widget.setProperty("face_id", face_id)
            face_widget.setProperty("is_deleted_view", is_deleted_view)
            face_widget.rightClicked.connect(self._on_face_right_clicked)
            face_widget.clicked.connect(self._on_face_clicked)

            current_idx = start_index + i
            row = current_idx // num_cols
            col = current_idx % num_cols

            self.unknown_faces_layout.addWidget(face_widget, row, col, Qt.AlignTop)

            loader = FaceLoader(
                self.face_loader_signals,
                face_id,
                face_row['filepath'],
                face_row['location']
            )
            self.threadpool.start(loader)

        self.current_face_count = start_index + len(face_list)

    def _load_existing_faces_async(self):
        """Carga caras nuevas Y limpia las que ya no deben estar (Sincronización)."""
        self.unknown_faces_group.setTitle("Caras Sin Asignar")
        self.cluster_faces_button.setEnabled(True)
        self.show_deleted_faces_button.setEnabled(True)

        # 1. Obtener de la DB qué caras deberían estar realmente aquí
        all_unknown_faces = self.db.get_unknown_faces()
        # Creamos un set de IDs válidos para búsqueda rápida
        valid_db_ids = {f['id'] for f in all_unknown_faces}

        # 2. LIMPIEZA: Revisar qué hay en pantalla y borrar lo que sobra
        # (Esto elimina las caras que acabas de borrar o las de la vista anterior)
        existing_ids_on_ui = set()
        count_widgets = self.unknown_faces_layout.count()

        # Iteramos hacia atrás para poder borrar sin romper el índice
        for i in range(count_widgets - 1, -1, -1):
            item = self.unknown_faces_layout.itemAt(i)
            if item and item.widget():
                widget = item.widget()

                # ¿Es un widget de cara?
                fid = widget.property("face_id")

                if fid is not None:
                    # Si la cara en pantalla NO está en la lista válida de la DB
                    if fid not in valid_db_ids:
                        widget.hide()          # Ocultar visualmente ya
                        widget.setParent(None) # Desvincular del layout
                        widget.deleteLater()   # Borrar de memoria
                    else:
                        # Si es válida, la guardamos para no volver a cargarla
                        existing_ids_on_ui.add(fid)

                # Limpiar mensajes antiguos de "No se han encontrado caras" si ahora hay datos
                elif isinstance(widget, QLabel) and valid_db_ids and "No se han encontrado" in widget.text():
                     widget.deleteLater()

        # 3. AÑADIR: Cargar solo las que faltan
        new_faces_to_add = [f for f in all_unknown_faces if f['id'] not in existing_ids_on_ui]

        # Si hay nuevas, las añadimos (append=True porque ya limpiamos nosotros)
        if new_faces_to_add:
            self._populate_face_grid_async(new_faces_to_add, is_deleted_view=False, append=True)

        # Si la DB está vacía y la UI también, mostrar mensaje de vacío
        elif not valid_db_ids and self.unknown_faces_layout.count() == 0:
             self._populate_face_grid_async([], is_deleted_view=False, append=False)

    @Slot()
    def _on_face_clicked(self):
        sender_widget = self.sender()
        if not sender_widget:
            return
        is_deleted_view = sender_widget.property("is_deleted_view")
        face_id = sender_widget.property("face_id")
        photo_path = sender_widget.property("photo_path")
        if not face_id or not photo_path:
            print("Clic en una cara que aún no tiene datos (cargando).")
            return
        self._set_status(f"Etiquetando Cara ID: {face_id}...")
        dialog = FaceClusterDialog(
            self.db,
            self.threadpool,
            [face_id],
            self
        )
        result = dialog.exec()
        if result == QDialog.Accepted:
            self._set_status("Cara etiquetada. Refrescando...")
            self._load_people_list()
            if is_deleted_view:
                self._show_deleted_faces()
            else:
                self._load_existing_faces_async()
        elif result == FaceClusterDialog.DeleteRole:
            self._set_status("Cara eliminada. Refrescando...")
            if is_deleted_view:
                self._show_deleted_faces()
            else:
                self._load_existing_faces_async()
        else:
            self._set_status("Etiquetado cancelado.")

    @Slot(QPoint)
    def _on_face_right_clicked(self, pos):
        sender_widget = self.sender()
        if not sender_widget:
            return
        face_id = sender_widget.property("face_id")
        is_deleted_view = sender_widget.property("is_deleted_view")
        menu = QMenu(self)
        if is_deleted_view:
            restore_action = menu.addAction("Restaurar cara")
            restore_action.triggered.connect(lambda: self._restore_face(face_id, sender_widget))
        else:
            delete_action = menu.addAction("Eliminar cara reconocida")
            delete_action.triggered.connect(lambda: self._delete_face(face_id, sender_widget))
        menu.exec(pos)

    def _delete_face(self, face_id: int, widget: QWidget):
        # 1. Borrar en DB
        self.db.soft_delete_face(face_id)

        # 2. Borrar visualmente INMEDIATAMENTE
        widget.hide()          # Ocultar
        widget.setParent(None) # Sacar del layout
        widget.deleteLater()   # Programar destrucción memoria

        self._set_status(f"Cara ID {face_id} eliminada.")

        # 3. Recargar (ahora nuestra nueva función _load... no la volverá a pintar)
        self._load_existing_faces_async()

    def _restore_face(self, face_id: int, widget: QWidget):
        self.db.restore_face(face_id)
        widget.deleteLater()
        self._set_status(f"Cara ID {face_id} restaurada.")
        self._show_deleted_faces()

    @Slot()
    def _show_deleted_faces(self):
        self.left_people_stack.setCurrentIndex(0)
        self.unknown_faces_group.setTitle("Caras Eliminadas")
        self.cluster_faces_button.setEnabled(False)
        self.show_deleted_faces_button.setEnabled(False)
        deleted_faces = self.db.get_deleted_faces()
        self._populate_face_grid_async(deleted_faces, is_deleted_view=True)
        self._set_status(f"Mostrando {len(deleted_faces)} caras eliminadas.")

    @Slot(QTreeWidgetItem, QTreeWidgetItem)
    def _on_person_selected(self, current_item: QTreeWidgetItem, previous_item: QTreeWidgetItem):
        if not current_item:
            return
        person_id = current_item.data(0, Qt.UserRole)
        if person_id == -1:
            self.left_people_stack.setCurrentIndex(0)
            self._load_existing_faces_async()
        elif person_id == -2:
            self.left_people_stack.setCurrentIndex(0)
            self._show_deleted_faces()
        elif person_id >= 0:
            self.left_people_stack.setCurrentIndex(1)
            person_name = current_item.text(0)
            self._load_photos_for_person(person_id, person_name)

    @Slot(int)
    def _update_face_scan_percentage(self, percentage):
        if not self.face_loading_label:
            self.face_loading_label = QLabel(f"Buscando caras de personas... {percentage}%")
            self.face_loading_label.setAlignment(Qt.AlignCenter)
            self.face_loading_label.setStyleSheet("font-size: 14pt;")
            self.face_container_layout.insertWidget(1, self.face_loading_label, 0, Qt.AlignCenter)
        else:
            self.face_loading_label.setText(f"Buscando caras de personas... {percentage}%")

    @Slot(int, str, str)
    def _handle_face_found(self, face_id: int, photo_path: str, location_str: str):
        """
        Se llama cada vez que el escáner encuentra una cara nueva.
        CORRECCIÓN: Filtra por la vista activa para no "ensuciar" la vista de Eliminadas.
        """
        # 1. Filtro de Pestaña: Si no estamos en Personas, no hacer nada (ahorra CPU)
        if self.tab_widget.currentWidget() != self.personas_tab_widget:
            return

        # --- 2. NUEVO FILTRO DE VISTA ---
        # Verificar qué opción del árbol está seleccionada.
        # ID -1 = Caras Sin Asignar.
        # ID -2 = Caras Eliminadas.
        # ID >= 0 = Persona Específica.
        current_item = self.people_tree_widget.currentItem()

        # Si no hay selección o NO estamos en "Caras Sin Asignar", ignoramos el evento visual.
        # La cara se guarda en la BD igualmente, y aparecerá cuando vuelvas a la sección correcta.
        if not current_item or current_item.data(0, Qt.UserRole) != -1:
            return

        face_widget = CircularFaceLabel(QPixmap())
        face_widget.setText("...")
        face_widget.setStyleSheet("background-color: #333333; border-radius: 50px; color: white;")

        face_widget.setProperty("face_id", face_id)
        face_widget.setProperty("photo_path", photo_path)
        face_widget.setProperty("is_deleted_view", False)

        face_widget.clicked.connect(self._on_face_clicked)
        face_widget.rightClicked.connect(self._on_face_right_clicked)

        # Corrección de Geometría (fallback de ancho)
        viewport_width = self.face_scroll_area.viewport().width() - 30
        if viewport_width < 300:
             viewport_width = max(400, self.width() - 350)

        num_cols = max(1, viewport_width // 110)

        row = self.current_face_count // num_cols
        col = self.current_face_count % num_cols

        self.unknown_faces_layout.addWidget(face_widget, row, col, Qt.AlignTop)

        self.current_face_count += 1

        loader = FaceLoader(
            self.face_loader_signals,
            face_id,
            photo_path,
            location_str
        )
        self.threadpool.start(loader)

    @Slot()
    def _handle_scan_finished(self):
        if self.face_loading_label:
            self.face_loading_label.deleteLater()
            self.face_loading_label = None
        if self.current_face_count == 0:
            placeholder = QLabel("No se han encontrado caras.")
            placeholder.setAlignment(Qt.AlignCenter)
            self.unknown_faces_layout.addWidget(placeholder, 0, 0, Qt.AlignCenter)

    @Slot()
    def _on_scan_thread_finished(self):
        """Slot de limpieza para el hilo de FOTOS."""
        if self.photo_thread:
            self.photo_thread.deleteLater()
        self.photo_thread = None
        self.photo_worker = None

    @Slot()
    def _on_video_scan_thread_finished(self):
        """Slot de limpieza para el hilo de VÍDEOS."""
        if self.video_thread:
            self.video_thread.deleteLater()
        self.video_thread = None
        self.video_worker = None

    @Slot()
    def _on_face_scan_thread_finished(self):
        self.face_scan_thread = None
        self.face_scan_worker = None

    @Slot(int, QPixmap, str)
    def _handle_face_loaded(self, face_id: int, pixmap: QPixmap, photo_path: str):
        placeholder = None
        for i in range(self.unknown_faces_layout.count()):
            widget = self.unknown_faces_layout.itemAt(i).widget()
            if widget and widget.property("face_id") == face_id:
                placeholder = widget
                break
        if placeholder:
            placeholder.setPixmap(pixmap)
            placeholder.setText("")
            placeholder.setProperty("photo_path", photo_path)
        else:
            if self.unknown_faces_group.title() != "Caras Sin Asignar":
                return
            face_widget = CircularFaceLabel(pixmap)
            face_widget.setProperty("face_id", face_id)
            face_widget.setProperty("photo_path", photo_path)
            face_widget.setProperty("is_deleted_view", False)
            face_widget.clicked.connect(self._on_face_clicked)
            face_widget.rightClicked.connect(self._on_face_right_clicked)
            num_cols = max(1, (self.face_scroll_area.viewport().width() - 30) // 110)
            row = self.current_face_count // num_cols
            col = self.current_face_count % num_cols
            self.unknown_faces_layout.addWidget(face_widget, row, col, Qt.AlignTop)
            self.current_face_count += 1

    @Slot(int)
    def _handle_face_load_failed(self, face_id: int):
        placeholder = None
        for i in range(self.unknown_faces_layout.count()):
            widget = self.unknown_faces_layout.itemAt(i).widget()
            if widget and widget.property("face_id") == face_id:
                placeholder = widget
                break
        if placeholder:
            placeholder.setText("Error")

    def closeEvent(self, event):
        """Limpia de forma segura y robusta todos los hilos antes de salir."""
        print("Cerrando aplicación... Por favor, espere.")
        self._set_status("Cerrando... limpiando recursos.")

        # 1. Guardar configuración
        try:
            self._save_photo_splitter_state()
            self._save_video_splitter_state()
            config_manager.set_thumbnail_size(self.current_thumbnail_size)
        except Exception: pass

        # 2. Parar vigilante
        if self.file_watcher:
            self.file_watcher.stop()

        # 3. Limpiar cola de miniaturas
        self.threadpool.clear()

        # 4. DETENER WORKERS DE ESCANEO (FOTOS Y VÍDEOS)
        # Corrección: Si no paran a tiempo, usamos terminate() para evitar el core dump.
        for thread, worker_name in [(self.photo_thread, 'photo_worker'), (self.video_thread, 'video_worker')]:
            if thread and thread.isRunning():
                worker = getattr(self, worker_name, None)
                if worker:
                    worker.is_running = False # Señal suave

                thread.quit()

                # Esperamos 1.5s a que cierre bien. Si no, forzamos.
                if not thread.wait(1500):
                    print(f"⚠️ {worker_name} tardando demasiado. Forzando detención...")
                    thread.terminate() # Mata el hilo del sistema
                    thread.wait()      # Asegura que está muerto antes de seguir

        # 5. DETENER HILO DE CARAS (EL MÁS PESADO)
        if self.face_scan_thread and self.face_scan_thread.isRunning():
            print("Deteniendo escáner de caras...")
            if self.face_scan_worker:
                # Parada lógica (cancela futuros de IA)
                self.face_scan_worker.stop()
                try: self.face_scan_worker.signals.scan_finished.disconnect()
                except: pass

            self.face_scan_thread.quit()

            # Esperamos 2s. Si Face Recognition está bloqueado en C++, no responderá al quit().
            if not self.face_scan_thread.wait(2000):
                print("🛑 El motor de IA no responde. Matando proceso...")
                self.face_scan_thread.terminate() # Obligatorio para evitar 'QThread Destroyed...'
                self.face_scan_thread.wait()      # Confirmar muerte

        # 6. CAJA FUERTE
        if hasattr(self, 'safe_thread') and self.safe_thread and self.safe_thread.isRunning():
             if hasattr(self, 'safe_worker'): self.safe_worker.is_running = False
             self.safe_thread.quit()
             self.safe_thread.wait(1000)

        # 7. DRIVE
        self._stop_cloud_operations()

        print("Limpieza finalizada. Adiós.")
        event.accept()

    # --- ¡NUEVO MÉTODO DE KEYPRESS! ---
    def keyPressEvent(self, event: QKeyEvent):
        """Maneja los atajos de teclado para el zoom."""

        # 1. Comprobar si Ctrl está presionado
        if event.modifiers() == Qt.ControlModifier:
            new_size = self.current_thumbnail_size

            # 2. Comprobar Ctrl + '+' (o '=')
            if event.key() == Qt.Key_Plus or event.key() == Qt.Key_Equal:
                new_size = min(self.MAX_THUMB_SIZE, self.current_thumbnail_size + self.THUMB_SIZE_STEP)

            # 3. Comprobar Ctrl + '-'
            elif event.key() == Qt.Key_Minus:
                new_size = max(self.MIN_THUMB_SIZE, self.current_thumbnail_size - self.THUMB_SIZE_STEP)

            else:
                super().keyPressEvent(event)
                return

            # 4. Si el tamaño ha cambiado, aplicarlo y guardarlo
            if new_size != self.current_thumbnail_size:
                self.current_thumbnail_size = new_size
                config_manager.set_thumbnail_size(new_size)

                # 5. Redibujar las vistas (igual que al redimensionar)
                if self.photos_by_year_month:
                    self._display_photos()
                if self.videos_by_year_month:
                    self._display_videos()

            event.accept() # Marcar el evento como manejado

        else:
            # Si no es Ctrl, pasar el evento
            super().keyPressEvent(event)

    @Slot()
    def _start_clustering(self):
        self.cluster_faces_button.setText("Procesando...")
        self.cluster_faces_button.setEnabled(False)
        self._set_status("Iniciando búsqueda de duplicados...")
        worker = ClusterWorker(self.cluster_signals, self.db.db_path)
        self.threadpool.start(worker)

    @Slot(list)
    def _handle_clusters_found(self, clusters: list):
        if not clusters:
            self._set_status("No se encontraron nuevos duplicados.")
            return
        self.cluster_queue = clusters
        self._set_status(f"¡Encontrados {len(self.cluster_queue)} grupos! Procesando...")
        self._process_cluster_queue()

    @Slot()
    def _handle_clustering_finished(self):
        self.cluster_faces_button.setText("Buscar Duplicados")
        self.cluster_faces_button.setEnabled(True)
        if not self.cluster_queue:
             self._set_status("Búsqueda de duplicados finalizada. No se encontraron grupos.")

    @Slot()
    def _process_cluster_queue(self):
        if not self.cluster_queue:
            self._set_status("¡Etiquetado de grupos completado!")
            self._load_existing_faces_async()
            return
        next_cluster_ids = self.cluster_queue.pop(0)
        self._set_status(f"Procesando grupo... quedan {len(self.cluster_queue)} grupos.")
        dialog = FaceClusterDialog(
            self.db,
            self.threadpool,
            next_cluster_ids,
            self
        )
        result = dialog.exec()
        if result == QDialog.Accepted:
            print(f"Grupo guardado. Quedan {len(self.cluster_queue)}.")
            self._load_people_list()
        elif result == FaceClusterDialog.SkipRole:
            print(f"Grupo omitido. Quedan {len(self.cluster_queue)}.")
        elif result == FaceClusterDialog.DeleteRole:
            print(f"Grupo eliminado. Quedan {len(self.cluster_queue)}.")
        else:
            print("Cancelado el etiquetado de grupos.")
            self.cluster_queue = []
            self._set_status("Etiquetado cancelado.")
            self._load_existing_faces_async()
            return
        QTimer.singleShot(100, self._process_cluster_queue)

    def _load_photos_for_person(self, person_id: int, person_name: str):
        self._set_status(f"Mostrando caras de {person_name}.")
        self.cluster_faces_button.setEnabled(False)
        self.show_deleted_faces_button.setEnabled(True)
        person_photos = self.db.get_faces_for_person(person_id)
        self._display_person_photos(person_photos, person_name)


    def _display_person_photos(self, photos_list: list, person_name: str):
        while self.person_photo_layout.count() > 0:
            item = self.person_photo_layout.takeAt(0)
            if item.widget(): item.widget().deleteLater()
        if not photos_list:
            placeholder = QLabel(f"No se encontraron fotos para {person_name}.")
            placeholder.setAlignment(Qt.AlignCenter)
            self.person_photo_layout.addWidget(placeholder)
            return
        photos_by_year_month = {}
        for row in photos_list:
            path, year, month = row['filepath'], row['year'], row['month']
            if year not in photos_by_year_month:
                photos_by_year_month[year] = {}
            if month not in photos_by_year_month[year]:
                photos_by_year_month[year][month] = []
            if path not in photos_by_year_month[year][month]:
                photos_by_year_month[year][month].append(path)
        viewport_width = self.left_people_stack.width() - 30

        # --- Modificación de Zoom para Pestaña Personas ---
        # Usar el zoom, pero no cambiar el TAMAÑO del label
        thumb_width = THUMBNAIL_SIZE[0] + 10
        num_cols = max(1, viewport_width // thumb_width)

        sorted_years = sorted(photos_by_year_month.keys(), reverse=True)
        for year in sorted_years:
            sorted_months = sorted(photos_by_year_month[year].keys(), reverse=True)
            for month in sorted_months:
                photos = photos_by_year_month[year][month]
                if not photos: continue
                try:
                    month_name = datetime.datetime.strptime(month, "%m").strftime("%B").capitalize()
                except ValueError:
                    month_name = "Mes Desconocido"
                group_label = QLabel(f"{month_name} {year}")
                group_label.setStyleSheet("font-size: 14pt; font-weight: bold; margin-top: 10px;")
                self.person_photo_layout.addWidget(group_label)
                photo_grid_widget = QWidget()
                photo_grid_layout = QGridLayout(photo_grid_widget)
                photo_grid_layout.setSpacing(5)
                for i, photo_path in enumerate(photos):
                    photo_label = ZoomableClickableLabel(photo_path)
                    photo_label.is_thumbnail_view = True
                    photo_label.setFixedSize(THUMBNAIL_SIZE[0] + 10, THUMBNAIL_SIZE[1] + 25)
                    photo_label.setToolTip(photo_path)
                    photo_label.setAlignment(Qt.AlignCenter)
                    photo_label.setText(Path(photo_path).name.split('.')[0] + "\nCargando...")
                    photo_label.setProperty("original_path", photo_path)
                    photo_label.setProperty("loaded", False)
                    photo_label.doubleClickedPath.connect(self._open_photo_detail)
                    row, col = i // num_cols, i % num_cols
                    photo_grid_layout.addWidget(photo_label, row, col)
                self.person_photo_layout.addWidget(photo_grid_widget)
        self.person_photo_layout.addStretch(1)
        QTimer.singleShot(100, self._load_person_visible_thumbnails)

    def _show_hidden_photos_view(self):
        """Muestra solo las fotos ocultas en el panel principal."""
        self._set_status("Cargando fotos ocultas...")

        # Limpiar layout existente
        while self.photo_container_layout.count() > 0:
            item = self.photo_container_layout.takeAt(0)
            if item.widget(): item.widget().deleteLater()

        # IMPORTANTE: Limpiar referencias a widgets antiguos para evitar RuntimeError
        self.photo_group_widgets.clear()
        self.photo_list_widget_items.clear()

        title = QLabel("Fotos Ocultas")
        title.setStyleSheet("font-size: 18pt; color: red; font-weight: bold; margin: 20px;")
        self.photo_container_layout.addWidget(title)

        hidden_paths = self.db.get_hidden_photos()

        if not hidden_paths:
            self.photo_container_layout.addWidget(QLabel("No hay fotos ocultas."))
            self.photo_container_layout.addStretch(1)
            return  # <--- Aquí salimos si no hay nada.

        # Si llegamos aquí, SÍ creamos el list_widget
        list_widget = PreviewListWidget()
        list_widget.setMovement(QListWidget.Static)
        list_widget.setSelectionMode(QAbstractItemView.ExtendedSelection)
        list_widget.setSpacing(20)

        list_widget.setContextMenuPolicy(Qt.CustomContextMenu)
        list_widget.customContextMenuRequested.connect(
            lambda pos, lw=list_widget: self._on_context_menu(pos, lw, is_video=False, is_hidden_view=True)
        )

        list_widget.setViewMode(QListWidget.IconMode)
        list_widget.setResizeMode(QListWidget.Adjust)

        list_widget.setIconSize(QSize(self.current_thumbnail_size, self.current_thumbnail_size))
        item_w = self.current_thumbnail_size + 8
        item_h = self.current_thumbnail_size + 8

        for path in hidden_paths:
            if not os.path.exists(path): continue
            item = QListWidgetItem("Cargando...")
            item.setSizeHint(QSize(item_w, item_h))
            item.setData(Qt.UserRole, path)
            item.setData(Qt.UserRole + 1, "not_loaded")
            list_widget.addItem(item)
            self.photo_list_widget_items[path] = item

        self.photo_container_layout.addWidget(list_widget)
        self.photo_container_layout.addStretch(1)
        QTimer.singleShot(100, self._load_main_visible_thumbnails)

    def _show_hidden_videos_view(self):
        """Muestra solo los vídeos ocultos en el panel principal."""
        self._set_status("Cargando vídeos ocultos...")

        while self.video_container_layout.count() > 0:
            item = self.video_container_layout.takeAt(0)
            if item.widget(): item.widget().deleteLater()

        self.video_list_widget_items.clear()

        title = QLabel("Vídeos Ocultos")
        title.setStyleSheet("font-size: 18pt; color: red; font-weight: bold; margin: 20px;")
        self.video_container_layout.addWidget(title)

        hidden_paths = self.db.get_hidden_videos()

        if not hidden_paths:
            self.video_container_layout.addWidget(QLabel("No hay vídeos ocultos."))
            self.video_container_layout.addStretch(1)
            return

        # Si llegamos aquí, SÍ creamos el list_widget
        list_widget = PreviewListWidget()
        list_widget.setMovement(QListWidget.Static)
        list_widget.setSelectionMode(QAbstractItemView.ExtendedSelection)
        list_widget.setSpacing(20)

        list_widget.setContextMenuPolicy(Qt.CustomContextMenu)
        list_widget.customContextMenuRequested.connect(
            lambda pos, lw=list_widget: self._on_context_menu(pos, lw, is_video=True, is_hidden_view=True)
        )
        list_widget.setViewMode(QListWidget.IconMode)
        list_widget.setResizeMode(QListWidget.Adjust)

        list_widget.setIconSize(QSize(self.current_thumbnail_size, self.current_thumbnail_size))
        item_w = self.current_thumbnail_size + 8
        item_h = self.current_thumbnail_size + 8

        for path in hidden_paths:
            if not os.path.exists(path): continue
            item = QListWidgetItem("Cargando...")
            item.setSizeHint(QSize(item_w, item_h))
            item.setData(Qt.UserRole, path)
            item.setData(Qt.UserRole + 1, "not_loaded")
            list_widget.addItem(item)
            self.video_list_widget_items[path] = item

        self.video_container_layout.addWidget(list_widget)
        self.video_container_layout.addStretch(1)
        QTimer.singleShot(100, self._load_visible_video_thumbnails)

    @Slot()
    def _open_help_dialog(self):
        """Abre la ventana de ayuda."""
        dialog = HelpDialog(self)
        dialog.exec()

    def _remove_red_eyes_for_selected(self, items):
        """Aplica la corrección de ojos rojos a los elementos seleccionados."""
        count = len(items)
        # Confirmación de seguridad
        confirm = QMessageBox.question(
            self,
            "Corrección de Ojos Rojos",
            f"Se intentarán corregir los ojos rojos en {count} foto(s).\n\n"
            "⚠️ Esto modificará el archivo original permanentemente.\n"
            "¿Deseas continuar?",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
        )

        if confirm != QMessageBox.StandardButton.Yes:
            return

        processed = 0
        successes = 0

        paths_to_update = [item.data(Qt.UserRole) for item in items]
        total = len(paths_to_update)

        for i, path in enumerate(paths_to_update):
            self._set_status(f"Corrigiendo ojos rojos ({i+1}/{total}): {Path(path).name}...")
            QApplication.processEvents() # Para que la UI no se congele

            if self._remove_red_eye_from_image(path):
                successes += 1

                # Borrar miniatura antigua de la caché para obligar a regenerarla
                # (Asumiendo que importaste hashlib y THUMBNAIL_DIR de thumbnail_generator o copiaste la lógica)
                # Una forma rápida sin importar es borrarla si sabemos la ruta,
                # o simplemente recargar el loader que la regenerará si detecta cambio (depende de tu implementación).
                # Aquí simplemente recargamos la vista.

            processed += 1

        self._set_status(f"Proceso finalizado. {successes} fotos corregidas de {processed}.")

        if successes > 0:
            # Refrescar la vista actual para ver cambios (o regenerar thumbnails)
            # Lo ideal sería invalidar la caché de thumbnails de estas fotos específicas
            # Como solución simple, recargamos la vista:
            self._display_photos()

    @Slot()
    def _on_gdrive_login_click(self):
        """Gestiona tanto Conectar como Desconectar."""

        # CASO 1: DESCONECTAR (LOGOUT)
        if self.is_drive_connected:
            self._perform_logout()
            return

        # CASO 2: CONECTAR (LOGIN)
        self.btn_gdrive.setEnabled(False)
        self.btn_gdrive.setText("Esperando navegador...")
        self._set_status("Abriendo navegador para inicio de sesión...")

        self.drive_login_thread = QThread()
        self.drive_login_worker = DriveLoginWorker()
        self.drive_login_worker.moveToThread(self.drive_login_thread)

        self.drive_login_thread.started.connect(self.drive_login_worker.run)
        self.drive_login_worker.login_success.connect(self._on_login_success_with_service)
        self.drive_login_worker.login_failed.connect(self._on_login_failure)

        self.drive_login_worker.finished.connect(self.drive_login_thread.quit)
        self.drive_login_worker.finished.connect(self.drive_login_worker.deleteLater)
        self.drive_login_thread.finished.connect(lambda: setattr(self, 'drive_login_thread', None))

        self.drive_login_thread.start()

    def _perform_logout(self):
        """
        Cierra sesión y realiza un BORRADO TOTAL de datos locales, caché e interfaz.
        """
        # 1. LOGOUT LÓGICO (Token)
        from drive_auth import DriveAuthenticator
        auth = DriveAuthenticator()
        if auth.logout():
            self._set_status("Sesión cerrada. Iniciando limpieza profunda...")
        else:
            self._set_status("Desconectado. Limpiando datos...")

        # 2. PARAR CUALQUIER PROCESO DE FONDO
        self._stop_cloud_operations()

        # 3. BORRADO DE BASE DE DATOS
        try:
            # Intentamos usar el método dedicado si existe
            if hasattr(self.db, 'clear_drive_data'):
                self.db.clear_drive_data()
            else:
                # Fallback manual
                with self.db.conn:
                    self.db.conn.execute("DELETE FROM drive_photos")
            print("Base de datos de Drive vaciada.")
        except Exception as e:
            print(f"Error limpiando DB: {e}")

        # 4. BORRADO FÍSICO (CACHÉ DE DISCO)
        # Definimos las rutas exactas
        cache_snapshot = os.path.join(self.root_cache, "drive_snapshot_cache")
        cache_full = os.path.join(self.root_cache, "drive_cache")

        for folder_path in [cache_snapshot, cache_full]:
            if os.path.exists(folder_path):
                try:
                    # Borramos la carpeta ENTERA y su contenido
                    shutil.rmtree(folder_path)
                    # La volvemos a crear vacía inmediatamente para evitar errores futuros
                    os.makedirs(folder_path)
                    print(f"Caché purgado y regenerado: {folder_path}")
                except Exception as e:
                    print(f"Error purgado caché {folder_path}: {e}")

        # 5. LIMPIEZA DE MEMORIA (RAM)
        self.is_drive_connected = False
        self.drive_service = None
        self.drive_manager = None
        self.current_drive_folder_id = None
        self.drive_photos_by_date = {} # ¡VITAL! Vaciar el diccionario de fotos
        self.drive_loaded_ids = set()
        self.cloud_photo_count = 0

        # 6. LIMPIEZA VISUAL (INTERFAZ) - ELIMINACIÓN AGRESIVA

        # A) Limpiar el árbol de fechas lateral
        self.cloud_date_tree.clear()

        # B) Limpiar el panel de fotos (Layout)
        # Usamos un bucle while para asegurar que no queda NADA
        while self.cloud_container_layout.count() > 0:
            item = self.cloud_container_layout.takeAt(0)
            widget = item.widget()
            if widget:
                widget.setParent(None) # Desvincular totalmente
                widget.deleteLater()   # Programar destrucción

        # C) Forzar repintado de la zona
        self.cloud_scroll_area.update()
        self.btn_show_tree.setVisible(False)
        self.btn_show_tree.setChecked(False)
        self.cloud_folder_panel.hide()
        self.cloud_folder_tree.clear()

        # 7. RESTAURAR ESTADO INICIAL DEL BOTÓN
        self.btn_gdrive.setText("Iniciar sesión con Google")
        self.btn_gdrive.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_DriveNetIcon))
        self.btn_gdrive.setStyleSheet("") # Quitar estilo verde
        self.btn_gdrive.setEnabled(True)

        self.btn_change_folder.setVisible(False)

        self._set_status("Desconectado. Todos los datos locales han sido eliminados.")

        # (Opcional) Mensaje emergente
        QMessageBox.information(self, "Desconectado", "Sesión cerrada y caché eliminado.")

    @Slot(object)
    def _on_login_success_with_service(self, service):
        """
        Recibe el objeto de conexión (service) desde el hilo de login
        y pasa el control a la función de éxito principal.
        """
        self.drive_service = service
        # Ahora llamamos a la función que activa la interfaz y cambia el botón
        self._on_login_success()
        # Mostrar el botón del árbol
        self.btn_show_tree.setVisible(True)

    @Slot()
    def _on_login_success(self):
        self._set_status("¡Conectado a Google Drive!")
        self.is_drive_connected = True  # <--- IMPORTANTE

        # Actualizar botón para que ahora sirva para desconectar
        self.btn_gdrive.setText("Desconectar de Google") # <--- CAMBIO DE TEXTO
        self.btn_gdrive.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_DialogCloseButton))
        self.btn_gdrive.setEnabled(True)
        self.btn_gdrive.setStyleSheet("background-color: #34a853; color: white; padding: 12px; font-weight: bold;")

        self.btn_change_folder.setVisible(True)
        self.btn_show_tree.setVisible(True)

        try:
            self.drive_manager = DriveManager()
            self.drive_manager.authenticate() # Esto ahora usará el token cargado

            folder_id = config_manager.get_drive_folder_id()

            if folder_id:
                self._set_status(f"Sincronizando carpeta guardada automáticamente...")
                # Lanzamos escaneo directo (ya optimizado)
                self._scan_drive_content(folder_id)
            else:
                self._select_drive_folder()

        except Exception as e:
            print(f"Error post-login: {e}")
            self._set_status(f"Error inicializando Drive: {e}")
            # Si falla la inicialización, forzamos logout visual
            self._perform_logout()

    @Slot(str)
    def _on_login_failure(self, error_message=None):
        """Maneja el fallo en el login."""
        self.btn_gdrive.setEnabled(True)
        self.btn_gdrive.setText("Reintentar conexión")
        if error_message:
            self._set_status(f"Conexión fallida: {error_message}")
        else:
            self._set_status("Conexión fallida. Verifique sus credenciales.")

    def _perform_google_login(self):
        try:
            self.drive_auth = DriveAuthenticator()
            # Esta línea bloquea el hilo hasta que el usuario inicia sesión en el navegador
            self.drive_service = self.drive_auth.get_service()

            # Si llegamos aquí, fue exitoso. Programar actualización de UI en el hilo principal
            QTimer.singleShot(0, self._on_login_success)

        except FileNotFoundError as e:
            QTimer.singleShot(0, lambda: QMessageBox.critical(self, "Error Fatal", str(e)))
        except Exception as e:
            print(f"Error de Login con Google: {e}")
            QTimer.singleShot(0, self._on_login_failure)

    def _select_drive_folder(self):
        """Abre el navegador de carpetas de Drive."""
        try:
            dialog = DriveFolderDialog(self.drive_manager, self)
            result = dialog.exec()

            if result == QDialog.Accepted:
                folder_id = dialog.selected_folder_id
                folder_name = dialog.selected_folder_name

                # 1. PARADA TOTAL: Frenar descargas antiguas
                self._stop_cloud_operations()

                # 2. LIMPIEZA VISUAL Y DE MEMORIA
                self.drive_photos_by_date = {}
                self.cloud_photo_count = 0
                self.cloud_date_tree.clear()
                # Limpiar widgets de fotos anteriores
                while self.cloud_container_layout.count() > 0:
                    item = self.cloud_container_layout.takeAt(0)
                    if item.widget(): item.widget().deleteLater()

                # Añadir un loading visual temporal
                self.cloud_container_layout.addWidget(QLabel("Cargando nueva carpeta..."))

                # Guardar configuración
                config_manager.set_drive_folder_id(folder_id)

                # Actualizar referencia actual
                self.current_drive_folder_id = folder_id
                self.current_drive_folder_name = folder_name

                self.btn_change_folder.setVisible(True)
                self.btn_change_folder.setText(f"Carpeta: {folder_name} (Cambiar)")

                self._set_status(f"Cambiando a carpeta: {folder_name}...")

                # --- ACTUALIZAR EL ÁRBOL DE CARPETAS ---
                self.cloud_folder_tree.clear() # Borrar árbol viejo

                # Si el panel está visible, cargamos la nueva raíz inmediatamente
                if self.btn_show_tree.isChecked():
                    self._load_folder_tree_root()

                # 3. INICIAR NUEVO ESCANEO
                self._scan_drive_content(folder_id)

            dialog.deleteLater()

        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Error", f"Error al abrir navegador de Drive: {e}")

    def _load_drive_from_db(self, root_folder_id):
        """Carga solo las fotos que pertenecen a la carpeta seleccionada."""
        self._set_status("Cargando caché local...")

        db_photos = self.db.get_all_drive_photos(root_folder_id)

        if not db_photos:
            # Si está vacía, limpiamos todo por si acaso
            self.drive_photos_by_date = {}
            self.drive_loaded_ids = set() # <--- LIMPIEZA
            self.cloud_photo_count = 0
            self._display_cloud_photos() # Limpia la pantalla
            return

        formatted_photos = []
        for row in db_photos:
            formatted_photos.append({
                'id': row['id'],
                'name': row['name'],
                'createdTime': row['created_time'],
                'mimeType': row['mime_type'],
                'thumbnailLink': row['thumbnail_link'],
                'webContentLink': row['web_content_link']
            })

        self.drive_photos_by_date = {}
        self.drive_loaded_ids = set() # <--- LIMPIEZA ANTES DE RELLENAR
        self.cloud_photo_count = 0

        self._classify_drive_items_in_memory(formatted_photos)
        self._display_cloud_photos()
        self._set_status(f"Caché cargado: {self.cloud_photo_count} fotos.")

    def _classify_drive_items_in_memory(self, items):
        """Clasifica en el diccionario de fechas EVITANDO DUPLICADOS."""
        for f in items:
            file_id = f.get('id')

            # --- FILTRO ANTI-DUPLICADOS ---
            if file_id in self.drive_loaded_ids:
                continue # ¡Ya tenemos esta foto! La saltamos.

            # Si es nueva, la registramos
            self.drive_loaded_ids.add(file_id)
            # ------------------------------

            created_time = f.get('createdTime', '')
            year = "Sin Fecha"
            month = "00"
            if created_time:
                try:
                    dt = datetime.datetime.strptime(created_time[:10], "%Y-%m-%d")
                    year = str(dt.year)
                    month = f"{dt.month:02d}"
                except: pass

            if year not in self.drive_photos_by_date:
                self.drive_photos_by_date[year] = {}
            if month not in self.drive_photos_by_date[year]:
                self.drive_photos_by_date[year][month] = []

            self.drive_photos_by_date[year][month].append(f)
            self.cloud_photo_count += 1

    def _scan_drive_content(self, folder_id):
        """Inicia el escaneo de Drive."""
        self.current_drive_folder_id = folder_id

        # 1. Carga inicial de lo que ya tengamos (para que no se vea vacío)
        self._load_drive_from_db(folder_id)

        self._set_status("Iniciando indexación en la nube...")

        self.drive_scan_thread = QThread()
        self.drive_scan_worker = DriveScanWorker(folder_id, self.db.db_path)
        self.drive_scan_worker.moveToThread(self.drive_scan_thread)

        self.set_drive_priority_low.connect(self.drive_scan_worker.set_slow_mode)

        self.drive_scan_thread.started.connect(self.drive_scan_worker.run)

        # CAMBIO: Ya no conectamos items_found porque lo hemos quitado
        # self.drive_scan_worker.items_found.connect(...) <--- ELIMINADO

        self.drive_scan_worker.progress.connect(self._set_status)
        self.drive_scan_worker.finished.connect(self._on_drive_scan_finished)

        self.drive_scan_worker.finished.connect(self.drive_scan_thread.quit)
        self.drive_scan_worker.finished.connect(self.drive_scan_worker.deleteLater)
        self.drive_scan_thread.finished.connect(self.drive_scan_thread.deleteLater)

        self.drive_scan_thread.start()

    @Slot(int)
    def _on_drive_scan_finished(self, total_count):
        """Se llama cuando termina el escaneo."""
        self._set_status(f"Indexación completada ({total_count} nuevos). Recargando vista...")

        # Volvemos a cargar desde la DB local para refrescar la pantalla con lo nuevo
        self._load_drive_from_db(self.current_drive_folder_id)

        # Forzar actualización visual
        self._display_cloud_photos()

        if self.cloud_photo_count == 0:
             from PySide6.QtWidgets import QMessageBox
             QMessageBox.information(self, "Aviso", "No se encontraron imágenes en esa carpeta.")

        self._set_status(f"Listo. {self.cloud_photo_count} fotos disponibles.")

    def _display_cloud_photos(self):
        """Dibuja la interfaz de Nube (Usa ajuste de altura automático)."""

        while self.cloud_container_layout.count() > 0:
            item = self.cloud_container_layout.takeAt(0)
            if item.widget(): item.widget().deleteLater()

        self.cloud_date_tree.clear()
        self.cloud_group_widgets = {}

        sorted_years = sorted(self.drive_photos_by_date.keys(), reverse=True)

        for year in sorted_years:
            year_item = QTreeWidgetItem(self.cloud_date_tree, [str(year)])

            year_label = QLabel(f"Año {year}")
            year_label.setStyleSheet("font-size: 16pt; font-weight: bold; margin-top: 20px; margin-bottom: 5px;")
            widgets_to_add_for_year = [year_label]
            self.cloud_group_widgets[str(year)] = year_label

            sorted_months = sorted(self.drive_photos_by_date[year].keys(), reverse=True)

            for month in sorted_months:
                photos = self.drive_photos_by_date[year][month]
                if not photos: continue

                try: month_name = datetime.datetime.strptime(month, "%m").strftime("%B").capitalize()
                except: month_name = "Desconocido"

                month_item = QTreeWidgetItem(year_item, [f"{month_name} ({len(photos)})"])
                month_item.setData(0, Qt.UserRole, f"{year}-{month}")

                month_label = QLabel(month_name)
                month_label.setStyleSheet("font-size: 14pt; font-weight: bold; margin-top: 10px;")
                widgets_to_add_for_year.append(month_label)
                self.cloud_group_widgets[f"{year}-{month}"] = month_label

                # --- CONFIGURACIÓN LISTWIDGET ---
                list_widget = PreviewListWidget()
                list_widget.setMovement(QListWidget.Static)
                list_widget.setSelectionMode(QAbstractItemView.ExtendedSelection)
                list_widget.setUniformItemSizes(False)
                list_widget.setViewMode(QListWidget.IconMode)
                list_widget.setResizeMode(QListWidget.Adjust)
                list_widget.setSpacing(10)

                list_widget.itemPressed.connect(self._handle_global_selection) # Corrección selección

                list_widget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
                list_widget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
                list_widget.setFrameShape(QFrame.NoFrame)

                list_widget.customContextMenuRequested.connect(
                    lambda pos, lw=list_widget: self._on_drive_context_menu(pos, lw)
                )
                list_widget.setContextMenuPolicy(Qt.CustomContextMenu)
                list_widget.previewRequested.connect(self._on_drive_preview_requested)

                thumb_size = self.current_thumbnail_size
                list_widget.setIconSize(QSize(thumb_size, thumb_size))
                item_w = thumb_size + 10
                item_h = thumb_size + 10

                for f in photos:
                    item = QListWidgetItem("Cargando...")
                    item.setToolTip(f['name'])
                    safe_data = {
                        'id': str(f['id']),
                        'name': str(f['name']),
                        'mimeType': f.get('mimeType',''),
                        'thumbnailLink': f.get('thumbnailLink',''),
                        'webContentLink': f.get('webContentLink','')
                    }
                    item.setData(Qt.UserRole, safe_data)
                    item.setData(Qt.UserRole + 1, "not_loaded")
                    item.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_FileIcon))
                    item.setSizeHint(QSize(item_w, item_h))
                    list_widget.addItem(item)

                # --- ALTURA INICIAL APROXIMADA ---
                rows = (len(photos) // 5) + 1
                initial_height = rows * (item_h + 10)
                list_widget.setFixedHeight(initial_height)

                # --- AUTOCORRECCIÓN DE ALTURA ---
                QTimer.singleShot(10, list_widget.adjust_height_to_content)

                widgets_to_add_for_year.append(list_widget)

            for w in widgets_to_add_for_year:
                self.cloud_container_layout.addWidget(w)

            year_item.setExpanded(True)

        self.cloud_container_layout.addStretch(1)

        # Ajuste extra por si el layout tarda en pintarse
        if self.cloud_scroll_area.widget():
             self.cloud_scroll_area.widget().adjustSize()

        QTimer.singleShot(50, self._load_visible_cloud_thumbnails)
        QTimer.singleShot(300, self._load_visible_cloud_thumbnails)

    @Slot(QTreeWidgetItem, QTreeWidgetItem)
    def _scroll_to_cloud_item(self, current, previous):
        """Navegación rápida al hacer clic en el árbol de fechas."""
        if not current: return

        key = ""
        user_data = current.data(0, Qt.UserRole)

        if current.parent(): # Es un mes
            # --- CORRECCIÓN ROBUSTA ---
            # Si es una Tupla/Lista: ('2023', '05') -> Formato Nuevo
            if isinstance(user_data, (list, tuple)) and len(user_data) >= 2:
                year, month = user_data[0], user_data[1]
                key = f"{year}-{month}"

            # Si es Texto: "2023-05" -> Formato Antiguo o Caché
            elif isinstance(user_data, str):
                key = user_data
            # --------------------------
        else:
            # Es un año
            key = current.text(0)

        target_widget = self.cloud_group_widgets.get(key)

        if target_widget:
            try:
                self.cloud_scroll_area.ensureWidgetVisible(target_widget, 0, 0)
                QTimer.singleShot(200, self._load_visible_cloud_thumbnails)
            except RuntimeError:
                pass

    def _load_visible_cloud_thumbnails(self):
        """
        Carga miniaturas visibles con PRIORIDAD ALTA y pre-carga las siguientes con PRIORIDAD BAJA.
        """
        viewport = self.cloud_scroll_area.viewport()

        # 1. Área visible inmediata (Prioridad 10)
        visible_rect = viewport.rect()

        # 2. Área de pre-carga: 2 pantallas más abajo (Prioridad 0)
        prefetch_rect = viewport.rect().adjusted(0, 0, 0, viewport.height() * 2)

        widget_contenedor = self.cloud_scroll_area.widget()
        if not widget_contenedor: return

        for list_widget in widget_contenedor.findChildren(PreviewListWidget):
            if not list_widget.isVisible(): continue

            # Mapear coordenadas de la lista al viewport
            pos = list_widget.mapTo(viewport, list_widget.rect().topLeft())
            rect = list_widget.rect().translated(pos)

            # Si la lista no está ni en visible ni en prefetch, la ignoramos para ahorrar CPU
            if not (visible_rect.intersects(rect) or prefetch_rect.intersects(rect)):
                continue

            for i in range(list_widget.count()):
                item = list_widget.item(i)

                if item.data(Qt.UserRole + 1) == "not_loaded":
                    # Calcular posición aproximada del item
                    # (No es exacto píxel a píxel por rendimiento, pero sirve para priorizar)

                    priority = 0 # Baja por defecto (Prefetch)

                    # Si la lista intersecta el área visible, asumimos prioridad alta
                    # para asegurar que se carguen rápido.
                    if visible_rect.intersects(rect):
                        priority = 10

                    data = item.data(Qt.UserRole)
                    thumb_link = data.get('thumbnailLink')
                    file_id = data.get('id')

                    if thumb_link and file_id:
                        item.setData(Qt.UserRole + 1, "loading")
                        worker = NetworkThumbnailLoader(thumb_link, file_id, self.thumb_signals)
                        # Lanzar con PRIORIDAD
                        self.threadpool.start(worker, priority)

    def _stop_cloud_operations(self):
        """Detiene de forma SEGURA cualquier descarga o escaneo."""
        self._set_status("Deteniendo operaciones actuales...")

        # 1. Vaciar cola de descargas de miniaturas
        self.threadpool.clear()

        # 2. Detener escáner de carpetas si existe
        if self.drive_scan_thread:
            try:
                # Intentamos acceder al objeto. Si ya fue borrado por C++,
                # esto lanzará un RuntimeError que capturamos abajo.
                if self.drive_scan_thread.isRunning():

                    if self.drive_scan_worker:
                        try:
                            self.drive_scan_worker.is_running = False
                            # Desconectar señales para evitar actualizaciones fantasma
                            self.drive_scan_worker.items_found.disconnect()
                        except Exception:
                            pass # Ya estaba desconectado o borrado

                    self.drive_scan_thread.quit()
                    self.drive_scan_thread.wait(1000)

            except RuntimeError:
                # El objeto C++ ya fue borrado (deleteLater), pero la variable Python seguía ahí.
                # No pasa nada, simplemente lo ignoramos.
                print("Aviso: El hilo anterior ya estaba eliminado.")
                self.drive_scan_thread = None

    def _check_auto_login(self):
        """Intenta conectar automáticamente si hay credenciales guardadas."""
        from drive_auth import DriveAuthenticator
        auth = DriveAuthenticator()

        if auth.has_credentials():
            self._set_status("Detectada sesión de Google anterior. Conectando...")
            # Intentamos obtener el servicio en modo silencioso (sin abrir navegador)
            service = auth.get_service(silent=True)

            if service:
                self.drive_service = service
                self._on_login_success()
            else:
                self._set_status("La sesión de Google caducó. Por favor, conecta de nuevo.")

    # --- LÓGICA DEL ÁRBOL DE DIRECTORIOS ---

    @Slot()
    def _toggle_drive_folder_tree(self):
        """Muestra u oculta el panel lateral de carpetas."""
        is_visible = self.btn_show_tree.isChecked()
        self.cloud_folder_panel.setVisible(is_visible)

        if is_visible:
            # Si lo abrimos y está vacío, cargamos la raíz
            if self.cloud_folder_tree.topLevelItemCount() == 0:
                self._load_folder_tree_root()

    def _load_folder_tree_root(self):
        """
        Carga la Carpeta Raíz como primer elemento del árbol.
        """
        if not self.current_drive_folder_id:
            return

        self.cloud_folder_tree.clear()

        # 1. Crear el elemento RAÍZ manualmente
        root_name = getattr(self, 'current_drive_folder_name', 'Carpeta Raíz')
        root_item = QTreeWidgetItem(self.cloud_folder_tree, [root_name])
        root_item.setData(0, Qt.UserRole, self.current_drive_folder_id)
        root_item.setIcon(0, self.style().standardIcon(QStyle.StandardPixmap.SP_DriveHDIcon))
        root_item.setExpanded(True) # Lo mostramos abierto

        # 2. Lanzar worker para cargar SUS hijos (las subcarpetas) dentro de este item
        self._launch_folder_loader(self.current_drive_folder_id, root_item)

    def _launch_folder_loader(self, folder_id, parent_item):
        """Crea y lanza el hilo para buscar carpetas."""

        # 1. ¡SEMÁFORO ROJO! Decimos al descargador de fotos que se calme
        self.set_drive_priority_low.emit(True)

        thread = QThread()
        worker = FolderLoaderWorker(folder_id, parent_item)
        worker.moveToThread(thread)

        self.active_folder_threads.append((thread, worker))

        thread.started.connect(worker.run)
        worker.finished.connect(self._on_folders_loaded)

        def cleanup():
            if (thread, worker) in self.active_folder_threads:
                self.active_folder_threads.remove((thread, worker))
            thread.quit()
            worker.deleteLater()
            thread.deleteLater()

        worker.finished.connect(cleanup)
        thread.start()

    @Slot(list, QTreeWidgetItem)
    def _on_folders_loaded(self, folders, parent_item):
        """Recibe la lista de carpetas y actualiza el árbol."""

        self.set_drive_priority_low.emit(False)

        # Si parent_item es Root (invisible), limpiamos el mensaje de "Cargando..." si lo hubiera
        if parent_item == self.cloud_folder_tree.invisibleRootItem():
             self.cloud_folder_tree.clear()
        else:
            # Quitar el item dummy "Cargando..."
            if parent_item.childCount() > 0:
                parent_item.removeChild(parent_item.child(0))

        if not folders:
            if parent_item == self.cloud_folder_tree.invisibleRootItem():
                 no_item = QTreeWidgetItem(self.cloud_folder_tree, ["(Sin subcarpetas)"])
                 no_item.setFlags(Qt.NoItemFlags)
            return

        for f in folders:
            item = QTreeWidgetItem(parent_item, [f['name']])
            item.setData(0, Qt.UserRole, f['id'])
            item.setIcon(0, self.style().standardIcon(QStyle.StandardPixmap.SP_DirIcon))

            # TRUCO: Añadimos un hijo dummy para que aparezca la flechita de expansión
            # (Lazy Loading: solo cargaremos sus hijos reales si el usuario expande)
            dummy = QTreeWidgetItem(item, ["Cargando..."])

        self.cloud_folder_tree.expandItem(parent_item)

    @Slot(QTreeWidgetItem)
    def _on_folder_tree_item_expanded(self, item):
        """Se llama al hacer clic en la flechita de expansión."""
        # Si tiene un solo hijo y es el dummy "Cargando...", procedemos a cargar
        if item.childCount() == 1 and item.child(0).text(0) == "Cargando...":
            folder_id = item.data(0, Qt.UserRole)
            if folder_id:
                self._launch_folder_loader(folder_id, item)

    @Slot(QTreeWidgetItem, int)
    def _on_folder_tree_item_clicked(self, item, column):
        """
        Gestiona la navegación:
        - Si es la Raíz -> Muestra TODO (Recursivo).
        - Si es Subcarpeta -> Muestra solo contenido de esa carpeta.
        """
        folder_id = item.data(0, Qt.UserRole)
        folder_name = item.text(0)

        if not folder_id:
            return

        # CASO 1: Hemos pulsado la Carpeta Raíz (Volver al inicio)
        if folder_id == self.current_drive_folder_id:
            self._set_status(f"Mostrando vista completa: {folder_name}")

            # Usamos la función original que carga TODO basado en el root_folder_id
            # Esto recupera todas las fotos recursivamente
            self._load_drive_from_db(self.current_drive_folder_id)

            # Forzamos repintado
            self.cloud_scroll_area.setUpdatesEnabled(False)
            self._display_cloud_photos()
            self.cloud_scroll_area.setUpdatesEnabled(True)
            return

        # CASO 2: Hemos pulsado una Subcarpeta
        self._set_status(f"Filtrando carpeta: {folder_name}...")
        self._load_specific_folder_view(folder_id)

    def _load_specific_folder_view(self, target_folder_id):
        """
        Carga en memoria y muestra SOLO las fotos de la carpeta indicada.
        """
        # 1. Obtener fotos filtradas de la DB
        db_photos = self.db.get_drive_photos_by_parent(target_folder_id)

        # Si no hay fotos en la DB todavía (quizás el scanner no llegó), avisamos visualmente
        # pero NO borramos la pantalla si está vacía para no flashear, a menos que sea necesario.

        # 2. Limpiar estructuras de memoria
        self.drive_photos_by_date = {}
        self.drive_loaded_ids = set()
        self.cloud_photo_count = 0

        # 3. Formatear datos (Igual que en _load_drive_from_db)
        formatted_photos = []
        for row in db_photos:
            formatted_photos.append({
                'id': row['id'],
                'name': row['name'],
                'createdTime': row['created_time'],
                'mimeType': row['mime_type'],
                'thumbnailLink': row['thumbnail_link'],
                'webContentLink': row['web_content_link']
            })

        # 4. Clasificar en memoria (Fechas)
        self._classify_drive_items_in_memory(formatted_photos)

        # 5. Redibujar la interfaz
        # Congelamos actualizaciones visuales para que sea instantáneo
        self.cloud_scroll_area.setUpdatesEnabled(False)
        self._display_cloud_photos()
        self.cloud_scroll_area.setUpdatesEnabled(True)

        self._set_status(f"Mostrando {self.cloud_photo_count} fotos de esta carpeta.")

    # ========================================================
    # GESTIÓN DE DUPLICADOS
    # ========================================================
    @Slot()
    def _start_duplicate_search(self):
        """Inicia el worker de búsqueda."""
        if not self.photos_by_year_month:
            QMessageBox.information(self, "Aviso", "Primero carga una carpeta con fotos.")
            return

        self.btn_duplicates.setEnabled(False)
        self.btn_duplicates.setText("Analizando...")
        self._set_status("Iniciando búsqueda visual de duplicados...")

        # Crear hilo y worker
        self.dup_thread = QThread()
        self.dup_worker = DuplicateFinderWorker(self.db.db_path)
        self.dup_worker.moveToThread(self.dup_thread)

        self.dup_thread.started.connect(self.dup_worker.run)
        self.dup_worker.progress.connect(self._set_status)
        self.dup_worker.finished.connect(self._on_duplicate_search_finished)

        # Limpieza automática
        self.dup_worker.finished.connect(self.dup_thread.quit)
        self.dup_worker.finished.connect(self.dup_worker.deleteLater)
        self.dup_thread.finished.connect(self.dup_thread.deleteLater)

        self.dup_thread.start()

    @Slot(dict)
    def _on_duplicate_search_finished(self, duplicates):
        """Recibe los resultados y abre el diálogo."""
        self.btn_duplicates.setEnabled(True)
        self.btn_duplicates.setText("Buscar Duplicados")
        self._set_status("Búsqueda finalizada.")

        if not duplicates:
            QMessageBox.information(self, "Resultado", "¡Genial! No se encontraron duplicados visuales.")
            return

        # Calcular total de fotos duplicadas
        total_dupes = sum(len(v) for v in duplicates.values())
        self._set_status(f"Encontrados {len(duplicates)} grupos ({total_dupes} fotos).")

        # Abrir diálogo
        dialog = DuplicateDialog(duplicates, self.db, self)
        dialog.exec()

        # Al cerrar, verificar si se borró algo para refrescar la galería
        deleted_files = dialog.get_deleted_items()
        if deleted_files:
            self._set_status(f"Se eliminaron {len(deleted_files)} fotos. Actualizando vista...")

            # Eliminamos las fotos borradas de la memoria de la app
            for path in deleted_files:
                self._remove_from_memory_struct(path, self.photos_by_year_month)

            # Redibujamos la pantalla de fotos
            self._display_photos()

    def _setup_safe_tab(self):
        layout = QVBoxLayout(self.safe_tab)

        # ESTADO BLOQUEADO (Igual que antes)
        self.locked_widget = QWidget()
        lock_layout = QVBoxLayout(self.locked_widget)
        lock_layout.setAlignment(Qt.AlignCenter)

        icon_lbl = QLabel("🔒")
        icon_lbl.setStyleSheet("font-size: 64px;")
        icon_lbl.setAlignment(Qt.AlignCenter)
        lock_layout.addWidget(icon_lbl)

        lbl = QLabel("Esta zona está protegida.")
        lbl.setAlignment(Qt.AlignCenter)
        lock_layout.addWidget(lbl)

        btn_unlock = QPushButton("Desbloquear Caja Fuerte")
        btn_unlock.setFixedWidth(200)
        btn_unlock.clicked.connect(self._unlock_safe)
        lock_layout.addWidget(btn_unlock, 0, Qt.AlignCenter)

        layout.addWidget(self.locked_widget)

        # ESTADO DESBLOQUEADO (Rediseñado)
        self.unlocked_widget = QWidget()
        self.unlocked_widget.setVisible(False)
        unlock_layout = QVBoxLayout(self.unlocked_widget)

        # Barra superior
        top_bar = QHBoxLayout()
        top_bar.addWidget(QLabel("📂 Archivos Protegidos (Desencriptados en memoria)"))
        btn_lock = QPushButton("Bloquear")
        btn_lock.clicked.connect(self._lock_safe)
        top_bar.addWidget(btn_lock, 0, Qt.AlignRight)
        unlock_layout.addLayout(top_bar)

        # Área de scroll (Igual que la pestaña fotos)
        self.safe_scroll = QScrollArea()
        self.safe_scroll.setWidgetResizable(True)

        # Contenedor interno VERTICAL (antes era Grid)
        self.safe_container = QWidget()
        self.safe_container_layout = QVBoxLayout(self.safe_container)
        self.safe_container_layout.setSpacing(0)

        self.safe_scroll.setWidget(self.safe_container)
        unlock_layout.addWidget(self.safe_scroll)

        layout.addWidget(self.unlocked_widget)

        self.current_safe_password = None

    def _unlock_safe(self):
        # Verificar si ya existe contraseña configurada
        if not config_manager.get_safe_password_hash():
            QMessageBox.information(self, "Configuración", "Primero debes añadir una foto a la caja fuerte para configurar la contraseña.")
            return

        dialog = LoginDialog(self)
        if dialog.exec() == QDialog.Accepted:
            self.current_safe_password = dialog.password
            self.locked_widget.setVisible(False)
            self.unlocked_widget.setVisible(True)
            self._load_safe_content()

    def _lock_safe(self):
        self.current_safe_password = None
        # Limpiar grid visualmente por seguridad
        while self.safe_grid.count():
            item = self.safe_grid.takeAt(0)
            if item.widget(): item.widget().deleteLater()

        self.unlocked_widget.setVisible(False)
        self.locked_widget.setVisible(True)

    def _load_safe_content(self):
        while self.safe_container_layout.count() > 0:
            item = self.safe_container_layout.takeAt(0)
            if item.widget(): item.widget().deleteLater()

        files = self.db.get_safe_files()
        if not files:
            lbl = QLabel("La caja fuerte está vacía.")
            lbl.setAlignment(Qt.AlignCenter)
            self.safe_container_layout.addWidget(lbl)
            return

        safe_data = {}
        for row in files:
            date_str = row['original_date']
            if not date_str or "-" not in date_str: date_str = "0000-00"
            year, month = date_str.split("-")
            if year not in safe_data: safe_data[year] = {}
            if month not in safe_data[year]: safe_data[year][month] = []
            safe_data[year][month].append(row)

        sorted_years = sorted(safe_data.keys(), reverse=True)
        thumb_size = self.current_thumbnail_size

        for year in sorted_years:
            year_label = QLabel(f"Año {year}")
            year_label.setStyleSheet("font-size: 16pt; font-weight: bold; margin-top: 20px; margin-bottom: 5px; color: #e74c3c;")
            self.safe_container_layout.addWidget(year_label)

            for month in sorted(safe_data[year].keys(), reverse=True):
                file_rows = safe_data[year][month]
                try:
                    month_name = datetime.datetime.strptime(month, "%m").strftime("%B").capitalize()
                except: month_name = "Desconocido"

                month_label = QLabel(month_name)
                month_label.setStyleSheet("font-size: 14pt; font-weight: bold; margin-top: 10px;")
                self.safe_container_layout.addWidget(month_label)

                list_widget = PreviewListWidget()
                list_widget.setMovement(QListWidget.Static)
                list_widget.setSelectionMode(QAbstractItemView.ExtendedSelection)
                list_widget.setSpacing(20)
                list_widget.setViewMode(QListWidget.IconMode)
                list_widget.setResizeMode(QListWidget.Adjust)
                list_widget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
                list_widget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
                list_widget.setFrameShape(QFrame.NoFrame)
                list_widget.setIconSize(QSize(thumb_size, thumb_size))

                list_widget.itemDoubleClicked.connect(self._safe_item_double_clicked)
                list_widget.setContextMenuPolicy(Qt.CustomContextMenu)
                list_widget.customContextMenuRequested.connect(
                    lambda pos, lw=list_widget: self._safe_list_context_menu(pos, lw)
                )

                for row in file_rows:
                    encrypted_path = row['encrypted_path']
                    original_name = Path(row['original_path']).name
                    media_type = row['media_type']

                    if not os.path.exists(encrypted_path): continue

                    item = QListWidgetItem()
                    item.setToolTip(original_name)
                    item.setText("")
                    item.setData(Qt.UserRole, row)

                    pixmap = QPixmap()
                    loaded = False

                    # --- INTENTO DE CARGA DE IMAGEN (FOTO O THUMBNAIL DE VIDEO) ---
                    img_bytes = None
                    try:
                        if media_type == 'photo':
                            # Desencriptar la foto en sí
                            img_bytes = CryptoManager.decrypt_to_bytes(encrypted_path, self.current_safe_password)
                        elif media_type == 'video':
                            # Desencriptar el THUMBNAIL asociado (.thumb)
                            thumb_enc_path = encrypted_path + ".thumb"
                            if os.path.exists(thumb_enc_path):
                                img_bytes = CryptoManager.decrypt_to_bytes(thumb_enc_path, self.current_safe_password)

                        if img_bytes:
                            pixmap.loadFromData(img_bytes)
                            if not pixmap.isNull():
                                scaled = pixmap.scaled(thumb_size, thumb_size, Qt.KeepAspectRatio, Qt.SmoothTransformation)

                                # Si es vídeo, pintamos el icono de PLAY encima de la foto
                                if media_type == 'video':
                                    painter = QPainter(scaled)
                                    icon = self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPlay)
                                    icon_dim = int(thumb_size * 0.4)
                                    x = (scaled.width() - icon_dim) // 2
                                    y = (scaled.height() - icon_dim) // 2
                                    # Pintar un fondo semitransparente para que se vea el play
                                    painter.setBrush(QColor(0, 0, 0, 128))
                                    painter.setPen(Qt.NoPen)
                                    painter.drawEllipse(x, y, icon_dim, icon_dim)
                                    icon.paint(painter, x, y, icon_dim, icon_dim)
                                    painter.end()

                                item.setIcon(QIcon(scaled))
                                item.setSizeHint(scaled.size())
                                loaded = True
                    except: pass

                    # --- FALLBACK (Si no hay thumb o falló) ---
                    if not loaded:
                        placeholder = QPixmap(thumb_size, thumb_size)
                        placeholder.fill(Qt.transparent)
                        painter = QPainter(placeholder)
                        painter.setRenderHint(QPainter.Antialiasing)

                        brush = QBrush(QColor("#454545"))
                        painter.setBrush(brush)
                        pen = QPen(QColor("#666666"))
                        pen.setWidth(2)
                        painter.setPen(pen)
                        rect_size = thumb_size - 2
                        painter.drawRoundedRect(1, 1, rect_size, rect_size, 4, 4)

                        icon_type = QStyle.StandardPixmap.SP_MediaPlay if media_type == 'video' else QStyle.StandardPixmap.SP_FileIcon
                        icon = self.style().standardIcon(icon_type)
                        icon_dim = int(thumb_size * 0.5)
                        x = (thumb_size - icon_dim) // 2
                        y = (thumb_size - icon_dim) // 2
                        icon.paint(painter, x, y, icon_dim, icon_dim)
                        painter.end()

                        item.setIcon(QIcon(placeholder))
                        item.setSizeHint(QSize(thumb_size, thumb_size))

                    list_widget.addItem(item)

                item_full_dim = thumb_size + list_widget.spacing()
                viewport_width = self.safe_scroll.viewport().width() - 30
                num_cols = max(1, viewport_width // item_full_dim)
                rows = (len(file_rows) + num_cols - 1) // num_cols
                total_height = (rows * item_full_dim) + 30
                list_widget.setFixedHeight(total_height)

                self.safe_container_layout.addWidget(list_widget)

        self.safe_container_layout.addStretch(1)

    def _safe_context_menu(self, pos, encrypted_path):
        menu = QMenu(self)
        action_restore = menu.addAction("Restaurar a Galería (Desencriptar)")
        action = menu.exec(QCursor.pos())

        if action == action_restore:
            self._restore_from_safe(encrypted_path)

    def _restore_from_safe(self, encrypted_path):
        """Restaura un archivo y recupera su fecha personalizada en el sistema."""
        # 1. Buscar info en DB
        cursor = self.db.conn.execute("SELECT * FROM safe_files WHERE encrypted_path = ?", (encrypted_path,))
        row = cursor.fetchone()
        if not row: return

        original_path = row['original_path']
        media_type = row['media_type']
        # Recuperamos la fecha que tenía antes de entrar (YYYY-MM)
        saved_date = row['original_date']

        try:
            # 2. Desencriptar el archivo principal (Esto crea un archivo con fecha de HOY)
            CryptoManager.process_file(encrypted_path, original_path, self.current_safe_password)

            # 3. Si es vídeo, limpiar también su thumbnail encriptado si existe
            if media_type == 'video':
                thumb_enc_path = encrypted_path + ".thumb"
                if os.path.exists(thumb_enc_path):
                    try: os.remove(thumb_enc_path)
                    except: pass

            # 4. Restaurar fechas en la BASE DE DATOS
            year = saved_date[:4]
            month = saved_date[5:7]

            if media_type == 'video':
                self.db.update_video_date(original_path, year, month)
            else:
                self.db.update_photo_date(original_path, year, month)

            # --- 5. CORRECCIÓN CRÍTICA: RESTAURAR FECHA EN EL ARCHIVO FÍSICO ---
            # Esto obliga al archivo en el disco a tener la fecha antigua, no la de hoy.
            self._update_file_metadata_on_disk(original_path, year, month)
            # -------------------------------------------------------------------

            # 6. Limpiar DB y archivo encriptado
            self.db.remove_from_safe(encrypted_path)
            if os.path.exists(encrypted_path):
                os.remove(encrypted_path)

            # 7. Notificar y refrescar
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.information(self, "Éxito", "Archivo restaurado a su ubicación original.")

            self._load_safe_content()
            self._perform_auto_refresh()

        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.critical(self, "Error", f"Error al restaurar: {e}")
            print(f"Error restaurando: {e}")

    def _move_to_safe_box(self, items, is_video):
        """Prepara y lanza el hilo de encriptación en segundo plano."""
        # 1. Gestionar contraseña
        password = None
        if not config_manager.get_safe_password_hash():
            dialog = CreatePasswordDialog(self)
            if dialog.exec() == QDialog.Accepted:
                password = dialog.password
                config_manager.set_safe_password_hash(password)
            else: return
        else:
            dialog = LoginDialog(self)
            if dialog.exec() == QDialog.Accepted:
                password = dialog.password
            else: return

        # 2. Recopilar datos para no pasar widgets al hilo
        items_data = []
        for item in items:
            path = item.data(Qt.UserRole)
            if path and os.path.exists(path):
                items_data.append((path, is_video))

        if not items_data: return

        self._set_status("Iniciando encriptación en segundo plano...")

        # 3. Configurar Worker y Thread
        self.safe_thread = QThread()
        self.safe_worker = MoveToSafeWorker(self.db.db_path, items_data, password)
        self.safe_worker.moveToThread(self.safe_thread)

        # Conectar señales
        self.safe_thread.started.connect(self.safe_worker.run)
        self.safe_worker.progress.connect(self._set_status)
        self.safe_worker.item_finished.connect(self._on_safe_item_processed)
        self.safe_worker.finished.connect(self._on_safe_worker_finished)

        # Limpieza automática
        self.safe_worker.finished.connect(self.safe_thread.quit)
        self.safe_worker.finished.connect(self.safe_worker.deleteLater)
        self.safe_thread.finished.connect(self.safe_thread.deleteLater)

        self.safe_thread.start()

    @Slot(QListWidgetItem)
    def _safe_item_double_clicked(self, item):
        """Abre la foto encriptada en el visor a pantalla completa."""
        row_data = item.data(Qt.UserRole)
        encrypted_path = row_data['encrypted_path']
        media_type = row_data['media_type']

        if media_type == 'video':
            QMessageBox.information(self, "Info", "La reproducción de vídeo encriptado en memoria aún no está soportada. Restáuralo para verlo.")
            return

        self._set_status("Desencriptando para visualización...")
        try:
            img_bytes = CryptoManager.decrypt_to_bytes(encrypted_path, self.current_safe_password)
            if img_bytes:
                pixmap = QPixmap()
                pixmap.loadFromData(img_bytes)
                if not pixmap.isNull():
                    # Usamos tu visor existente
                    preview = ImagePreviewDialog(pixmap, self)
                    preview.show_with_animation()
                    self._set_status("Visualizando archivo seguro.")
                else:
                    self._set_status("Error: Imagen corrupta o formato no soportado.")
        except Exception as e:
            print(f"Error visualización safe: {e}")

    def _safe_list_context_menu(self, pos, list_widget):
        """Menú contextual para la lista de la caja fuerte."""
        item = list_widget.itemAt(pos)
        if not item: return

        menu = QMenu(self)
        action_restore = menu.addAction("Restaurar a Galería")
        action_restore.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_ArrowUp))

        action = menu.exec(list_widget.mapToGlobal(pos))

        if action == action_restore:
            # Obtenemos los seleccionados
            selected_items = list_widget.selectedItems()
            count = 0
            for sel in selected_items:
                data = sel.data(Qt.UserRole)
                self._restore_from_safe(data['encrypted_path']) # Reutilizamos tu función de restaurar
                count += 1

            if count > 0:
                self._load_safe_content() # Recargar UI
                # También refrescamos la galería principal por si acaso
                self._perform_auto_refresh()

    def _restore_from_safe(self, encrypted_path):
        """Restaura un archivo y recupera su fecha personalizada en la BD y el sistema."""
        # 1. Buscar info en DB
        cursor = self.db.conn.execute("SELECT * FROM safe_files WHERE encrypted_path = ?", (encrypted_path,))
        row = cursor.fetchone()
        if not row: return

        original_path = row['original_path']
        media_type = row['media_type']
        # Recuperamos la fecha guardada (YYYY-MM)
        saved_date = row['original_date']

        # Separar año y mes
        if saved_date and "-" in saved_date:
            year = saved_date.split("-")[0]
            month = saved_date.split("-")[1]
        else:
            year, month = "0000", "00"

        try:
            # 2. Desencriptar el archivo principal
            CryptoManager.process_file(encrypted_path, original_path, self.current_safe_password)

            # 3. Limpiar thumbnail encriptado si existe (para vídeos)
            if media_type == 'video':
                thumb_enc_path = encrypted_path + ".thumb"
                if os.path.exists(thumb_enc_path):
                    try: os.remove(thumb_enc_path)
                    except: pass

            # --- 4. CORRECCIÓN: INSERTAR EN LA BASE DE DATOS (NO ACTUALIZAR) ---
            # Como la foto se borró al entrar, ahora debemos CREARLA de nuevo con la fecha correcta.
            with self.db.conn:
                if media_type == 'video':
                    self.db.conn.execute("""
                        INSERT OR REPLACE INTO videos (filepath, year, month, is_hidden)
                        VALUES (?, ?, ?, 0)
                    """, (original_path, year, month))
                else:
                    # Insertamos y ponemos scanned_for_faces=0 para que vuelva a buscar caras
                    self.db.conn.execute("""
                        INSERT OR REPLACE INTO photos (filepath, year, month, scanned_for_faces, is_hidden)
                        VALUES (?, ?, ?, 0, 0)
                    """, (original_path, year, month))
            # -------------------------------------------------------------------

            # 5. Restaurar fecha física del archivo (para que coincida)
            self._update_file_metadata_on_disk(original_path, year, month)

            # 6. Limpiar DB Safe y archivo encriptado
            self.db.remove_from_safe(encrypted_path)
            if os.path.exists(encrypted_path):
                os.remove(encrypted_path)

            # 7. Notificar y refrescar
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.information(self, "Éxito", "Archivo restaurado a su ubicación original.")

            self._load_safe_content()
            self._perform_auto_refresh()

        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.critical(self, "Error", f"Error al restaurar: {e}")
            print(f"Error restaurando: {e}")

    @Slot(str, bool)
    def _on_safe_item_processed(self, original_path, is_video):
        """Se llama cada vez que el worker termina con un archivo."""
        # Eliminamos el elemento de la memoria de la aplicación
        if is_video:
            self._remove_from_memory_struct(original_path, self.videos_by_year_month)
        else:
            self._remove_from_memory_struct(original_path, self.photos_by_year_month)

    @Slot()
    def _on_safe_worker_finished(self):
        """Se llama cuando todos los archivos se han movido."""
        self._set_status("Proceso de caja fuerte finalizado.")

        # Refrescar las vistas
        if self.videos_by_year_month:
            self._display_videos()
        if self.photos_by_year_month:
            self._display_photos()

        # Si la caja fuerte está abierta, refrescarla también para ver los nuevos items
        if hasattr(self, 'unlocked_widget') and self.unlocked_widget.isVisible():
            self._load_safe_content()

        QMessageBox.information(self, "Completado", "Los archivos se han movido a la caja fuerte correctamente.")

    # ==========================================================
    # LÓGICA DE ÁRBOLES DE DIRECTORIO LOCALES (FOTOS Y VÍDEOS)
    # ==========================================================

    @Slot()
    def _toggle_photo_folder_tree(self):
        """Muestra/Oculta el árbol de fotos con gestión precisa del espacio."""
        # 1. Capturar tamaños ACTUALES antes de cambiar nada
        current_sizes = self.main_splitter.sizes() # [Izq, Centro, Der]

        should_show = self.btn_show_photo_tree.isChecked()
        self.photo_folder_panel.setVisible(should_show)

        if should_show:
            # --- ABRIR ---
            # Si estaba colapsado (ancho < 50), le damos 280px quitándoselos al centro.
            if current_sizes[0] < 50:
                target_width = 280
                # Nuevo Centro = Centro Actual - Lo que ocupa el árbol
                new_center = max(100, current_sizes[1] - target_width)

                # [280, Resto, Derecha_Intacta]
                self.main_splitter.setSizes([target_width, new_center, current_sizes[2]])

            # Carga perezosa de datos
            if self.photo_folder_tree.topLevelItemCount() == 0 and self.current_directory:
                self._load_local_tree_root(self.photo_folder_tree, self.current_directory)
        else:
            # --- CERRAR ---
            # Sumamos el ancho del árbol (current_sizes[0]) al centro.
            # La derecha (current_sizes[2]) se queda IGUAL.
            new_center = current_sizes[1] + current_sizes[0]
            self.main_splitter.setSizes([0, new_center, current_sizes[2]])

    @Slot()
    def _toggle_video_folder_tree(self):
        """Muestra/Oculta el árbol de vídeos con gestión precisa del espacio."""
        current_sizes = self.video_splitter.sizes()

        should_show = self.btn_show_video_tree.isChecked()
        self.video_folder_panel.setVisible(should_show)

        if should_show:
            # --- ABRIR ---
            if current_sizes[0] < 50:
                target_width = 280
                new_center = max(100, current_sizes[1] - target_width)
                self.video_splitter.setSizes([target_width, new_center, current_sizes[2]])

            if self.video_folder_tree.topLevelItemCount() == 0 and self.current_directory:
                self._load_local_tree_root(self.video_folder_tree, self.current_directory)
        else:
            # --- CERRAR ---
            new_center = current_sizes[1] + current_sizes[0]
            self.video_splitter.setSizes([0, new_center, current_sizes[2]])

    def _load_local_tree_root(self, tree_widget, root_path):
        """Carga la raíz del árbol local."""
        tree_widget.clear()
        root_name = Path(root_path).name
        root_item = QTreeWidgetItem(tree_widget, [root_name])
        root_item.setData(0, Qt.UserRole, root_path)
        root_item.setIcon(0, self.style().standardIcon(QStyle.StandardPixmap.SP_DirIcon))
        root_item.setExpanded(True)

        # Cargar primer nivel de subcarpetas
        self._populate_local_item(root_item, root_path)

    def _populate_local_item(self, parent_item, folder_path):
        """Busca subcarpetas y las añade al item."""
        try:
            # Listar directorios (no ocultos)
            entries = []
            with os.scandir(folder_path) as it:
                for entry in it:
                    if entry.is_dir() and not entry.name.startswith('.'):
                        entries.append(entry)

            # Ordenar alfabéticamente
            entries.sort(key=lambda e: e.name.lower())

            for entry in entries:
                item = QTreeWidgetItem(parent_item, [entry.name])
                item.setData(0, Qt.UserRole, entry.path)
                item.setIcon(0, self.style().standardIcon(QStyle.StandardPixmap.SP_DirIcon))

                # Chequeo rápido de si tiene hijos para añadir dummy (Lazy Load)
                has_subdirs = False
                try:
                    with os.scandir(entry.path) as sub_it:
                        for sub in sub_it:
                            if sub.is_dir() and not sub.name.startswith('.'):
                                has_subdirs = True
                                break
                except: pass

                if has_subdirs:
                    QTreeWidgetItem(item, ["Cargando..."])

        except Exception as e:
            print(f"Error leyendo carpeta {folder_path}: {e}")

    @Slot(QTreeWidgetItem)
    def _on_local_folder_tree_expanded(self, item):
        """Carga perezosa al expandir."""
        if item.childCount() == 1 and item.child(0).text(0) == "Cargando...":
            item.removeChild(item.child(0)) # Quitar dummy
            folder_path = item.data(0, Qt.UserRole)
            if folder_path:
                self._populate_local_item(item, folder_path)

    @Slot(QTreeWidgetItem, int)
    def _on_photo_folder_tree_clicked(self, item, column):
        path = item.data(0, Qt.UserRole)
        if not path: return

        # Si es la raíz, quitamos el filtro
        if path == self.current_directory:
            self.current_photo_filter_path = None
            self._set_status(f"Mostrando todas las fotos de: {Path(path).name}")
        else:
            self.current_photo_filter_path = path
            self._set_status(f"Filtrando fotos en: {Path(path).name}")

        self._display_photos() # Redibujar con filtro

    @Slot(QTreeWidgetItem, int)
    def _on_video_folder_tree_clicked(self, item, column):
        path = item.data(0, Qt.UserRole)
        if not path: return

        if path == self.current_directory:
            self.current_video_filter_path = None
            self._set_status(f"Mostrando todos los vídeos de: {Path(path).name}")
        else:
            self.current_video_filter_path = path
            self._set_status(f"Filtrando vídeos en: {Path(path).name}")

        self._display_videos() # Redibujar con filtro

    def _handle_global_selection(self, item):
        """
        Limpia la selección de todas las demás listas cuando el usuario hace clic en una.
        Permite mantener la selección múltiple si se pulsa Ctrl.
        """
        sender_list = self.sender()
        if not sender_list: return

        # Si el usuario pulsa Control, asumimos que quiere seleccionar cosas de varios meses
        if QApplication.keyboardModifiers() & Qt.ControlModifier:
            return

        # Buscar el contenedor padre (el widget dentro del ScrollArea)
        # Esto funciona para Fotos, Vídeos y Nube indistintamente
        parent_widget = sender_list.parent()
        if not parent_widget: return

        # Recorrer TODAS las listas hermanas y limpiar su selección
        for other_list in parent_widget.findChildren(PreviewListWidget):
            if other_list != sender_list:
                # Bloqueamos señales para evitar bucles recursivos innecesarios
                other_list.blockSignals(True)
                other_list.clearSelection()
                other_list.blockSignals(False)

def run_visagevault():
    """Función para iniciar la aplicación con Splash Screen corregido (PySide6)."""
    app = QApplication(sys.argv)

    # --- 1. INSTANCIAR LA APP PRIMERO ---
    window = VisageVaultApp()

    # --- 2. PREPARAR IMAGEN ---
    splash_path = "AnabasaSoft.png"
    if not os.path.exists(splash_path):
        splash_path = resource_path("AnabasaSoft.png")

    pixmap = QPixmap(splash_path)

    if pixmap.isNull():
        pixmap = QPixmap(resource_path("visagevault.png")).scaled(
            600, 400, Qt.KeepAspectRatio, Qt.SmoothTransformation
        )

    # --- 3. CONFIGURAR SPLASH SCREEN (CORRECCIÓN) ---
    # ERROR ANTERIOR: QSplashScreen(window, pixmap) -> No permitido en PySide6
    # SOLUCIÓN: Instanciar solo con pixmap y asignar padre después.
    splash = QSplashScreen(pixmap)

    # Asignamos la ventana principal como padre explícitamente.
    # Los flags son vitales:
    # - Qt.Window: Para que sea una ventana flotante y no se incruste dentro de la app.
    # - Qt.FramelessWindowHint: Para quitar los bordes.
    # - Qt.WindowStaysOnTopHint: Para reforzar que esté encima.
    splash.setParent(window, Qt.Window | Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)

    # Bloqueo Modal: Impide clics en la ventana 'padre' (window)
    splash.setWindowModality(Qt.ApplicationModal)

    # --- 4. MOSTRAR EN ORDEN ---
    window.showMaximized() # Mostramos la App
    splash.show()          # Mostramos el Splash (al ser hijo, aparecerá encima)

    app.processEvents()    # Asegurar renderizado inmediato

    # --- 5. ESPERAR 2 SEGUNDOS ---
    loop = QEventLoop()
    QTimer.singleShot(2000, loop.quit)
    loop.exec()

    # --- 6. TERMINAR ---
    splash.finish(window)
    sys.exit(app.exec())

if __name__ == "__main__":
    run_visagevault()