main_simple.py

# -*- coding: utf-8 -*-
"""
Aplicación de Copia de Seguridad Rápida para Windows
Versión Simplificada y Funcional
"""

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import os
import shutil
import zipfile
import threading
from datetime import datetime
from pathlib import Path
import json
import time
import hashlib
import subprocess
from collections import defaultdict
import re

# Importación opcional de psutil
try:
    import psutil
    PSUTIL_AVAILABLE = True
except ImportError:
    PSUTIL_AVAILABLE = False
    print("Advertencia: psutil no está disponible. Algunas funciones de monitoreo del sistema estarán deshabilitadas.")

# Nombres reservados de Windows
NOMBRES_RESERVADOS_WINDOWS = {
    'con', 'prn', 'aux', 'nul',
    'com1', 'com2', 'com3', 'com4', 'com5', 'com6', 'com7', 'com8', 'com9',
    'lpt1', 'lpt2', 'lpt3', 'lpt4', 'lpt5', 'lpt6', 'lpt7', 'lpt8', 'lpt9'
}

# Caracteres problemáticos en nombres de archivos
CARACTERES_PROBLEMATICOS = r'[<>:"|?*\x00-\x1f]'

def es_nombre_reservado_windows(nombre):
    """Verificar si un nombre de archivo es reservado en Windows"""
    if not nombre:
        return False
    
    # Obtener solo el nombre base sin extensión
    nombre_base = os.path.splitext(nombre.lower())[0]
    return nombre_base in NOMBRES_RESERVADOS_WINDOWS

def tiene_caracteres_problematicos(ruta):
    """Verificar si una ruta contiene caracteres problemáticos"""
    return bool(re.search(CARACTERES_PROBLEMATICOS, ruta))

def normalizar_ruta(ruta):
    """Normalizar ruta convirtiendo separadores mixtos y resolviendo problemas"""
    if not ruta:
        return ""
    
    try:
        # Convertir todos los separadores a formato Windows
        ruta_normalizada = ruta.replace('/', '\\')
        
        # Remover separadores duplicados
        while '\\\\' in ruta_normalizada:
            ruta_normalizada = ruta_normalizada.replace('\\\\', '\\')
        
        # Normalizar la ruta usando os.path
        ruta_normalizada = os.path.normpath(ruta_normalizada)
        
        return ruta_normalizada
    except Exception:
        return ruta

def es_ruta_muy_larga(ruta):
    """Verificar si una ruta excede el límite de Windows (260 caracteres)"""
    ruta_normalizada = normalizar_ruta(ruta)
    return len(ruta_normalizada) > 260

def truncar_nombre_inteligente(nombre, max_length=100):
    """Truncar nombre de archivo de forma inteligente preservando extensión"""
    if not nombre or len(nombre) <= max_length:
        return nombre
    
    # Separar nombre y extensión
    nombre_base, extension = os.path.splitext(nombre)
    
    # Calcular espacio disponible para el nombre base
    espacio_disponible = max_length - len(extension) - 3  # -3 para "..."
    
    if espacio_disponible <= 0:
        return nombre[:max_length]
    
    # Truncar y agregar indicador
    nombre_truncado = nombre_base[:espacio_disponible] + "..." + extension
    return nombre_truncado

def sanitizar_nombre_archivo(nombre):
    """Sanitizar nombre de archivo removiendo caracteres problemáticos"""
    if not nombre:
        return "archivo_sin_nombre"
    
    # Remover caracteres problemáticos
    nombre_limpio = re.sub(CARACTERES_PROBLEMATICOS, '_', nombre)
    
    # Si es nombre reservado, agregar prefijo
    if es_nombre_reservado_windows(nombre_limpio):
        nombre_limpio = f"backup_{nombre_limpio}"
    
    # Truncar si es muy largo
    nombre_limpio = truncar_nombre_inteligente(nombre_limpio)
    
    return nombre_limpio

def validar_ruta_archivo(ruta_completa):
    """
    Validar si una ruta de archivo es segura para procesar
    Retorna (es_valida, razon_error)
    """
    try:
        if not ruta_completa:
            return False, "Ruta vacía"
        
        # Normalizar la ruta primero
        ruta_normalizada = normalizar_ruta(ruta_completa)
        
        # Intentar acceso básico primero
        try:
            # Verificar si el archivo existe usando ruta normalizada
            if not os.path.exists(ruta_normalizada):
                return False, "Archivo no existe"
        except (OSError, ValueError) as e:
            # Si falla con ruta normalizada, intentar con UNC
            try:
                ruta_unc = obtener_ruta_segura(ruta_normalizada)
                if not os.path.exists(ruta_unc):
                    return False, f"Archivo inaccesible: {str(e)}"
                ruta_normalizada = ruta_unc
            except Exception:
                return False, f"Ruta problemática: {str(e)}"
        
        # Verificar permisos de lectura
        try:
            if not os.access(ruta_normalizada, os.R_OK):
                return False, "Sin permisos de lectura"
        except Exception:
            return False, "Error verificando permisos"
        
        # Obtener nombre del archivo
        nombre_archivo = os.path.basename(ruta_normalizada)
        
        # Verificar nombre reservado
        if es_nombre_reservado_windows(nombre_archivo):
            return False, f"Nombre reservado de Windows: {nombre_archivo}"
        
        # Verificar caracteres problemáticos en el nombre original
        if tiene_caracteres_problematicos(nombre_archivo):
            return False, "Contiene caracteres problemáticos"
        
        return True, "OK"
        
    except Exception as e:
        return False, f"Error de validación: {str(e)}"

def obtener_ruta_segura(ruta_original):
    """Convertir ruta a formato seguro usando prefijo UNC si es necesario"""
    try:
        # Normalizar primero
        ruta_normalizada = normalizar_ruta(ruta_original)
        
        # Si la ruta es muy larga y no tiene prefijo UNC
        if es_ruta_muy_larga(ruta_normalizada) and not ruta_normalizada.startswith('\\\\?\\'):
            # Usar prefijo UNC para rutas largas
            if ruta_normalizada.startswith('\\\\'):
                # Ruta de red
                return f'\\\\?\\UNC\\{ruta_normalizada[2:]}'
            else:
                # Ruta local - obtener ruta absoluta primero
                try:
                    ruta_absoluta = os.path.abspath(ruta_normalizada)
                    return f'\\\\?\\{ruta_absoluta}'
                except Exception:
                    return f'\\\\?\\{ruta_normalizada}'
        
        return ruta_normalizada
    except Exception:
        return ruta_original

def detectar_archivos_problematicos_especificos(directorio):
    """
    SISTEMA ULTRA-AGRESIVO de pre-escaneo para detectar TODOS los archivos problemáticos
    que causan el error 'path is on mount \\\\?\\nul'
    """
    archivos_problematicos = []
    
    # Lista COMPLETA de nombres reservados (incluyendo variaciones)
    nombres_reservados_completos = {
        'nul', 'con', 'prn', 'aux', 'clock$',
        'com1', 'com2', 'com3', 'com4', 'com5', 'com6', 'com7', 'com8', 'com9',
        'lpt1', 'lpt2', 'lpt3', 'lpt4', 'lpt5', 'lpt6', 'lpt7', 'lpt8', 'lpt9',
        # Variaciones con extensiones
        'nul.txt', 'con.txt', 'prn.txt', 'aux.txt',
        'nul.log', 'con.log', 'prn.log', 'aux.log',
        # Variaciones con espacios y puntos
        'nul.', 'con.', 'prn.', 'aux.',
        ' nul', ' con', ' prn', ' aux',
        'nul ', 'con ', 'prn ', 'aux '
    }
    
    # Caracteres ULTRA-problemáticos
    caracteres_ultra_problematicos = ['<', '>', ':', '"', '|', '?', '*', '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f']
    
    try:
        print(f"🔍 ESCANEO ULTRA-AGRESIVO iniciado en: {directorio}")
        
        # Usar listdir para escaneo inicial más seguro
        items = []
        try:
            items = os.listdir(directorio)
        except Exception as e:
            print(f"❌ Error listando directorio {directorio}: {e}")
            return archivos_problematicos
        
        for item in items:
            item_path = os.path.join(directorio, item)
            nombre_lower = item.lower().strip()
            
            # 1. DETECTAR NOMBRES RESERVADOS (ultra-agresivo)
            es_reservado = False
            for reservado in nombres_reservados_completos:
                if nombre_lower == reservado or nombre_lower.startswith(reservado + '.'):
                    es_reservado = True
                    break
            
            if es_reservado:
                archivos_problematicos.append({
                    'ruta': item_path,
                    'nombre': item,
                    'razon': f'NOMBRE RESERVADO DETECTADO: {nombre_lower}',
                    'tipo': 'nombre_reservado_critico'
                })
                print(f"🚫 CRÍTICO: Nombre reservado detectado: {item}")
                continue
            
            # 2. DETECTAR CARACTERES ULTRA-PROBLEMÁTICOS
            tiene_caracteres_criticos = False
            for char in caracteres_ultra_problematicos:
                if char in item:
                    tiene_caracteres_criticos = True
                    break
            
            if tiene_caracteres_criticos:
                archivos_problematicos.append({
                    'ruta': item_path,
                    'nombre': item,
                    'razon': 'CARACTERES CRÍTICOS DETECTADOS',
                    'tipo': 'caracteres_criticos'
                })
                print(f"🚫 CRÍTICO: Caracteres problemáticos en: {item}")
                continue
            
            # 3. DETECTAR RUTAS EXTREMADAMENTE LARGAS (límite ultra-conservador)
            if len(item_path) > 200:  # Límite MUY conservador
                archivos_problematicos.append({
                    'ruta': item_path,
                    'nombre': item,
                    'razon': f'RUTA CRÍTICA: {len(item_path)} caracteres (límite: 200)',
                    'tipo': 'ruta_critica'
                })
                print(f"🚫 CRÍTICO: Ruta muy larga: {item}")
                continue
            
            # 4. DETECTAR NOMBRES QUE EMPIEZAN/TERMINAN CON ESPACIOS O PUNTOS
            if item.startswith(' ') or item.endswith(' ') or item.startswith('.') or item.endswith('.'):
                archivos_problematicos.append({
                    'ruta': item_path,
                    'nombre': item,
                    'razon': 'FORMATO CRÍTICO: espacios/puntos al inicio/final',
                    'tipo': 'formato_critico'
                })
                print(f"🚫 CRÍTICO: Formato problemático: '{item}'")
                continue
            
            # 5. DETECTAR NOMBRES VACÍOS O SOLO ESPACIOS
            if not item.strip():
                archivos_problematicos.append({
                    'ruta': item_path,
                    'nombre': item,
                    'razon': 'NOMBRE VACÍO O SOLO ESPACIOS',
                    'tipo': 'nombre_vacio'
                })
                print(f"🚫 CRÍTICO: Nombre vacío detectado")
                continue
                
    except Exception as e:
        print(f"❌ ERROR CRÍTICO en pre-escaneo de {directorio}: {e}")
    
    if archivos_problematicos:
        print(f"⚠️  TOTAL ARCHIVOS PROBLEMÁTICOS DETECTADOS: {len(archivos_problematicos)}")
    
    return archivos_problematicos

def listdir_recursivo_seguro(directorio, archivos_problematicos_globales):
    """
    FALLBACK RECURSIVO: Implementación manual de walk usando listdir()
    para casos donde os.walk() falla completamente
    """
    resultados = []
    
    try:
        print(f"🔄 FALLBACK RECURSIVO activado para: {directorio}")
        
        # Listar contenido del directorio actual
        try:
            items = os.listdir(directorio)
        except Exception as e:
            print(f"❌ Error listando {directorio}: {e}")
            return resultados
        
        archivos_actuales = []
        directorios_actuales = []
        
        for item in items:
            item_path = os.path.join(directorio, item)
            
            # Verificar si es problemático
            es_problematico = False
            for prob in archivos_problematicos_globales:
                if prob['ruta'] == item_path:
                    es_problematico = True
                    break
            
            if es_problematico:
                print(f"🚫 FALLBACK: Saltando item problemático: {item}")
                continue
            
            try:
                if os.path.isfile(item_path):
                    archivos_actuales.append(item)
                elif os.path.isdir(item_path):
                    directorios_actuales.append(item)
            except Exception as e:
                print(f"⚠️  FALLBACK: Error verificando {item}: {e}")
                continue
        
        # Agregar resultado actual
        resultados.append((directorio, directorios_actuales.copy(), archivos_actuales))
        
        # Recursión en subdirectorios
        for subdir in directorios_actuales:
            subdir_path = os.path.join(directorio, subdir)
            try:
                sub_resultados = listdir_recursivo_seguro(subdir_path, archivos_problematicos_globales)
                resultados.extend(sub_resultados)
            except Exception as e:
                print(f"⚠️  FALLBACK: Error en subdirectorio {subdir}: {e}")
                continue
        
    except Exception as e:
        print(f"❌ FALLBACK: Error crítico en {directorio}: {e}")
    
    return resultados

def os_walk_seguro(directorio_origen, callback_estado=None):
    """
    🚀 SISTEMA RADICAL ANTI-NUL: NUNCA USA os.walk()
    Implementación 100% recursiva manual que ELIMINA completamente el error 'nul'
    """
    def actualizar_estado(mensaje):
        print(mensaje)
        if callback_estado:
            try:
                callback_estado(mensaje)
            except Exception:
                pass  # Ignorar errores de callback
    
    actualizar_estado(f"🚀 SISTEMA RADICAL ANTI-NUL activado para: {directorio_origen}")
    actualizar_estado("⚡ NUNCA usaremos os.walk() - Solo listdir() recursivo")
    
    # INTERCEPTOR INMEDIATO: Verificar si el directorio raíz es problemático
    try:
        nombre_base = os.path.basename(directorio_origen).lower()
        if nombre_base in NOMBRES_RESERVADOS_WINDOWS:
            actualizar_estado(f"🚫 DIRECTORIO RAÍZ PROBLEMÁTICO DETECTADO: {nombre_base}")
            actualizar_estado("⚠️  SALTANDO directorio completo para evitar error 'nul'")
            return
    except Exception as e:
        actualizar_estado(f"⚠️  Error verificando directorio raíz: {e}")
    
    # FASE 1: PRE-ESCANEO ULTRA-AGRESIVO (OPCIONAL)
    actualizar_estado("🔍 FASE 1: Pre-escaneo ultra-agresivo...")
    archivos_problematicos_globales = []
    
    try:
        archivos_problematicos_globales = detectar_archivos_problematicos_especificos(directorio_origen)
        if archivos_problematicos_globales:
            actualizar_estado(f"⚠️  DETECTADOS {len(archivos_problematicos_globales)} archivos problemáticos:")
            for item in archivos_problematicos_globales[:3]:
                actualizar_estado(f"   🚫 {item['nombre']}: {item['razon']}")
            if len(archivos_problematicos_globales) > 3:
                actualizar_estado(f"   ... y {len(archivos_problematicos_globales) - 3} más")
    except Exception as e:
        actualizar_estado(f"⚠️  Error en pre-escaneo (continuando sin él): {e}")
        # Continuar sin pre-escaneo si falla
    
    # FASE 2: LISTDIR RECURSIVO RADICAL (NUNCA os.walk)
    actualizar_estado("🔄 FASE 2: Iniciando listdir recursivo RADICAL...")
    
    try:
        for resultado in listdir_recursivo_radical(directorio_origen, archivos_problematicos_globales, callback_estado):
            yield resultado
    except Exception as e:
        actualizar_estado(f"🚫 ERROR EN LISTDIR RADICAL: {e}")
        # Último recurso: devolver directorio vacío
        actualizar_estado("🆘 ÚLTIMO RECURSO: Devolviendo directorio vacío...")
        yield directorio_origen, [], []


def listdir_recursivo_radical(directorio, archivos_problematicos_globales, callback_estado=None):
    """
    🔥 IMPLEMENTACIÓN RADICAL: Listdir recursivo que NUNCA falla con 'nul'
    """
    def actualizar_estado(mensaje):
        print(mensaje)
        if callback_estado:
            try:
                callback_estado(mensaje)
            except Exception:
                pass  # Ignorar errores de callback
    
    try:
        actualizar_estado(f"📁 Procesando directorio: {directorio}")
        
        # INTERCEPTOR INMEDIATO: Verificar nombre del directorio
        try:
            nombre_dir = os.path.basename(directorio).lower()
            if nombre_dir in NOMBRES_RESERVADOS_WINDOWS:
                actualizar_estado(f"🚫 DIRECTORIO RESERVADO DETECTADO: {nombre_dir}")
                actualizar_estado("   ⏭️  SALTANDO directorio completo...")
                return  # Saltar este directorio completamente
        except Exception:
            pass  # Continuar si no se puede verificar el nombre
        
        # Intentar listar contenido del directorio con MÁXIMA PROTECCIÓN
        items = []
        try:
            items = os.listdir(directorio)
        except OSError as e:
            error_msg = str(e).lower()
            if 'nul' in error_msg or 'mount' in error_msg:
                actualizar_estado(f"🚫 DIRECTORIO PROBLEMÁTICO DETECTADO: {directorio}")
                actualizar_estado(f"   Error: {e}")
                actualizar_estado("   ⏭️  SALTANDO directorio completo...")
                return  # Saltar este directorio completamente
            else:
                actualizar_estado(f"⚠️  Error de acceso en {directorio}: {e}")
                return
        except Exception as e:
            actualizar_estado(f"⚠️  Error inesperado listando {directorio}: {e}")
            return
        
        # Separar archivos y directorios de forma ULTRA-SEGURA
        archivos_seguros = []
        directorios_seguros = []
        
        for item in items:
            # INTERCEPTOR INMEDIATO: Verificar nombre del item
            try:
                nombre_base = item.lower()
                if nombre_base in NOMBRES_RESERVADOS_WINDOWS:
                    actualizar_estado(f"🚫 ITEM RESERVADO DETECTADO: {item}")
                    continue  # Saltar inmediatamente
            except Exception:
                pass  # Continuar si no se puede verificar el nombre
            
            item_path = os.path.join(directorio, item)
            
            # Verificar si está en la lista de problemáticos
            es_problematico = False
            for prob in archivos_problematicos_globales:
                if prob['ruta'] == item_path:
                    actualizar_estado(f"🚫 SALTANDO item problemático: {item}")
                    es_problematico = True
                    break
            
            if es_problematico:
                continue
            
            # Verificar tipo de item de forma ULTRA-SEGURA
            try:
                if os.path.isfile(item_path):
                    archivos_seguros.append(item)
                elif os.path.isdir(item_path):
                    directorios_seguros.append(item)
            except OSError as e:
                error_msg = str(e).lower()
                if 'nul' in error_msg or 'mount' in error_msg:
                    actualizar_estado(f"🚫 ITEM PROBLEMÁTICO DETECTADO: {item}")
                    actualizar_estado(f"   Error: {e}")
                    continue  # Saltar este item
                else:
                    actualizar_estado(f"⚠️  Error verificando {item}: {e}")
                    continue
            except Exception as e:
                actualizar_estado(f"⚠️  Error inesperado con {item}: {e}")
                continue
        
        # Devolver resultado para el directorio actual
        yield directorio, directorios_seguros, archivos_seguros
        
        # Procesar subdirectorios recursivamente
        for subdir in directorios_seguros:
            subdir_path = os.path.join(directorio, subdir)
            try:
                for resultado in listdir_recursivo_radical(subdir_path, archivos_problematicos_globales, callback_estado):
                    yield resultado
            except Exception as e:
                actualizar_estado(f"⚠️  Error procesando subdirectorio {subdir}: {e}")
                continue
                
    except Exception as e:
        actualizar_estado(f"🚫 ERROR CRÍTICO en listdir_recursivo_radical: {e}")
        return

def validar_directorio_origen(directorio):
    """Validar directorio origen antes de os.walk()"""
    try:
        if not directorio:
            return False, "Directorio vacío"
        
        # Normalizar ruta
        dir_normalizado = normalizar_ruta(directorio)
        
        # Verificar existencia
        if not os.path.exists(dir_normalizado):
            return False, "Directorio no existe"
        
        # Verificar que es directorio
        if not os.path.isdir(dir_normalizado):
            return False, "No es un directorio"
        
        # Verificar permisos
        if not os.access(dir_normalizado, os.R_OK):
            return False, "Sin permisos de lectura"
        
        # Intentar listar contenido básico
        try:
            list(os.listdir(dir_normalizado))
        except Exception as e:
            return False, f"Error accediendo al directorio: {str(e)}"
        
        return True, "OK"
        
    except Exception as e:
        return False, f"Error validando directorio: {str(e)}"

class CopyNestApp:
    def __init__(self, root):
        self.root = root
        self.root.title("🗂️ CopyNest - Backup Inteligente v2.0")
        self.root.geometry("800x600")
        self.root.minsize(700, 500)
        
        # Configurar colores
        self.bg_color = '#2c3e50'
        self.fg_color = '#ecf0f1'
        self.accent_color = '#3498db'
        
        self.root.configure(bg=self.bg_color)
        
        # Variables
        self.carpeta_origen = tk.StringVar()
        self.carpeta_destino = tk.StringVar()
        self.nombre_copia = tk.StringVar()
        self.incluir_ocultos = tk.BooleanVar()
        self.modo_eficiente = tk.BooleanVar(value=True)
        self.usar_nombre_carpeta = tk.BooleanVar(value=True)
        self.verificar_integridad = tk.BooleanVar(value=False)
        self.nivel_compresion = tk.IntVar(value=6)
        self.crear_log = tk.BooleanVar(value=True)
        self.progreso = tk.DoubleVar()
        self.estado_texto = tk.StringVar(value="✨ Listo para crear copia de seguridad")
        
        # Variables para estadísticas
        self.tiempo_inicio = None
        self.tiempo_estimado = tk.StringVar(value="")
        self.velocidad_procesamiento = tk.StringVar(value="")
        
        # Historial de copias
        self.historial_copias = []
        
        # Filtros personalizados
        self.filtros_personalizados = set()
        
        # Lista de archivos problemáticos para logging
        self.archivos_problematicos = []
        
        # Configuración por defecto
        self.nombre_copia.set(f"backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
        
        # Carpetas y archivos a excluir en modo eficiente
        self.exclusiones_eficientes = {
            'node_modules', 'dist', 'build', '.next', '.nuxt', 'out',
            '.git', '.svn', '.hg', 'coverage', '.nyc_output',
            'logs', '*.log', 'npm-debug.log*', 'yarn-debug.log*',
            'yarn-error.log*', '.DS_Store', 'Thumbs.db',
            '__pycache__', '*.pyc', '*.pyo', '*.pyd', '.Python',
            'env', 'venv', '.venv', '.env.local', '.env.development.local',
            '.env.test.local', '.env.production.local', 'target',
            'bin', 'obj', '.vs', '.vscode/settings.json'
        }
        
        self.crear_interfaz()
        self.cargar_configuracion()
        self.centrar_ventana()
        
    def crear_interfaz(self):
        """Crear la interfaz de usuario"""
        # Canvas y scrollbar para scroll vertical
        canvas = tk.Canvas(self.root, bg=self.bg_color, highlightthickness=0)
        scrollbar = tk.Scrollbar(self.root, orient="vertical", command=canvas.yview)
        scrollable_frame = tk.Frame(canvas, bg=self.bg_color)
        
        scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
        canvas.configure(yscrollcommand=scrollbar.set)
        
        # Configurar scroll con rueda del mouse
        def _on_mousewheel(event):
            canvas.yview_scroll(int(-1*(event.delta/120)), "units")
        canvas.bind_all("<MouseWheel>", _on_mousewheel)
        
        # Empaquetar canvas y scrollbar
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # Frame principal con padding dentro del canvas
        main_frame = tk.Frame(scrollable_frame, bg=self.bg_color)
        main_frame.pack(fill='both', expand=True, padx=20, pady=20)
        
        # Título
        title_label = tk.Label(main_frame, 
                              text="🗂️ Copia de Seguridad Rápida",
                              font=('Segoe UI', 18, 'bold'),
                              bg=self.bg_color, fg=self.fg_color)
        title_label.pack(pady=(0, 10))
        
        subtitle_label = tk.Label(main_frame,
                                 text="Crea copias de seguridad comprimidas de forma rápida y sencilla",
                                 font=('Segoe UI', 10),
                                 bg=self.bg_color, fg='#bdc3c7')
        subtitle_label.pack(pady=(0, 20))
        
        # Sección de carpetas
        self.crear_seccion_carpetas(main_frame)
        
        # Sección de configuración
        self.crear_seccion_configuracion(main_frame)
        
        # Sección de configuración avanzada
        self.crear_seccion_avanzada(main_frame)
        
        # Sección de estadísticas
        self.crear_seccion_estadisticas(main_frame)
        
        # Sección de progreso
        self.crear_seccion_progreso(main_frame)
        
        # Sección de historial
        self.crear_seccion_historial(main_frame)
        
        # Botones
        self.crear_botones(main_frame)
        
    def crear_seccion_carpetas(self, parent):
        """Crear sección de selección de carpetas"""
        # Frame para carpetas
        carpetas_frame = tk.LabelFrame(parent, text="📁 Selección de Carpetas",
                                      font=('Segoe UI', 12, 'bold'),
                                      bg=self.bg_color, fg=self.fg_color,
                                      bd=2, relief='groove')
        carpetas_frame.pack(fill='x', pady=(0, 15))
        
        # Carpeta origen
        tk.Label(carpetas_frame, text="Carpeta de origen:",
                font=('Segoe UI', 10), bg=self.bg_color, fg=self.fg_color).pack(anchor='w', padx=10, pady=(10, 5))
        
        origen_frame = tk.Frame(carpetas_frame, bg=self.bg_color)
        origen_frame.pack(fill='x', padx=10, pady=(0, 10))
        
        self.entry_origen = tk.Entry(origen_frame, textvariable=self.carpeta_origen,
                                    font=('Segoe UI', 10), width=50)
        self.entry_origen.pack(side='left', fill='x', expand=True)
        
        tk.Button(origen_frame, text="📂 Seleccionar",
                 command=self.seleccionar_origen,
                 bg=self.accent_color, fg='white',
                 font=('Segoe UI', 9, 'bold'),
                 relief='flat', padx=15).pack(side='right', padx=(10, 0))
        
        # Carpeta destino
        tk.Label(carpetas_frame, text="Carpeta de destino:",
                font=('Segoe UI', 10), bg=self.bg_color, fg=self.fg_color).pack(anchor='w', padx=10, pady=(10, 5))
        
        destino_frame = tk.Frame(carpetas_frame, bg=self.bg_color)
        destino_frame.pack(fill='x', padx=10, pady=(0, 15))
        
        self.entry_destino = tk.Entry(destino_frame, textvariable=self.carpeta_destino,
                                     font=('Segoe UI', 10), width=50)
        self.entry_destino.pack(side='left', fill='x', expand=True)
        
        tk.Button(destino_frame, text="📂 Seleccionar",
                 command=self.seleccionar_destino,
                 bg=self.accent_color, fg='white',
                 font=('Segoe UI', 9, 'bold'),
                 relief='flat', padx=15).pack(side='right', padx=(10, 0))
        
    def crear_seccion_configuracion(self, parent):
        """Crear sección de configuración"""
        config_frame = tk.LabelFrame(parent, text="⚙️ Configuración",
                                    font=('Segoe UI', 12, 'bold'),
                                    bg=self.bg_color, fg=self.fg_color,
                                    bd=2, relief='groove')
        config_frame.pack(fill='x', pady=(0, 15))
        
        # Checkbox para usar nombre de carpeta automáticamente
        self.check_nombre_auto = tk.Checkbutton(config_frame, 
                                               text="📁 Usar nombre de carpeta origen + timestamp",
                                               variable=self.usar_nombre_carpeta,
                                               command=self.actualizar_nombre_archivo,
                                               font=('Segoe UI', 10),
                                               bg=self.bg_color, fg=self.fg_color,
                                               selectcolor=self.bg_color,
                                               activebackground=self.bg_color,
                                               activeforeground=self.fg_color)
        self.check_nombre_auto.pack(anchor='w', padx=10, pady=(10, 5))
        
        # Nombre del archivo
        tk.Label(config_frame, text="Nombre del archivo de copia:",
                font=('Segoe UI', 10), bg=self.bg_color, fg=self.fg_color).pack(anchor='w', padx=10, pady=(10, 5))
        
        self.entry_nombre = tk.Entry(config_frame, textvariable=self.nombre_copia,
                                    font=('Segoe UI', 10), width=50)
        self.entry_nombre.pack(fill='x', padx=10, pady=(0, 10))
        
        # Checkbox para modo eficiente
        self.check_eficiente = tk.Checkbutton(config_frame, 
                                             text="⚡ Modo eficiente (excluir node_modules, dist, .git, etc.)",
                                             variable=self.modo_eficiente,
                                             command=self.mostrar_exclusiones,
                                             font=('Segoe UI', 10),
                                             bg=self.bg_color, fg=self.fg_color,
                                             selectcolor=self.bg_color,
                                             activebackground=self.bg_color,
                                             activeforeground=self.fg_color)
        self.check_eficiente.pack(anchor='w', padx=10, pady=(0, 5))
        
        # Checkbox para archivos ocultos
        self.check_ocultos = tk.Checkbutton(config_frame, 
                                           text="🔍 Incluir archivos y carpetas ocultos",
                                           variable=self.incluir_ocultos,
                                           font=('Segoe UI', 10),
                                           bg=self.bg_color, fg=self.fg_color,
                                           selectcolor=self.bg_color,
                                           activebackground=self.bg_color,
                                           activeforeground=self.fg_color)
        self.check_ocultos.pack(anchor='w', padx=10, pady=(0, 5))
        
        # Botón para ver exclusiones
        tk.Button(config_frame, text="📋 Ver carpetas excluidas en modo eficiente",
                 command=self.mostrar_exclusiones,
                 bg='#95a5a6', fg='white',
                 font=('Segoe UI', 9),
                 relief='flat', padx=10, pady=5).pack(anchor='w', padx=10, pady=(0, 15))
    
    def crear_seccion_avanzada(self, parent):
        """Crear sección de configuración avanzada"""
        avanzada_frame = tk.LabelFrame(parent, text="🔧 Configuración Avanzada",
                                      font=('Segoe UI', 12, 'bold'),
                                      bg=self.bg_color, fg=self.fg_color,
                                      bd=2, relief='groove')
        avanzada_frame.pack(fill='x', pady=(0, 15))
        
        # Frame para organizar en columnas
        columnas_frame = tk.Frame(avanzada_frame, bg=self.bg_color)
        columnas_frame.pack(fill='x', padx=10, pady=10)
        
        # Columna izquierda
        col_izq = tk.Frame(columnas_frame, bg=self.bg_color)
        col_izq.pack(side='left', fill='both', expand=True)
        
        # Nivel de compresión
        tk.Label(col_izq, text="🗜️ Nivel de compresión (0-9):",
                font=('Segoe UI', 10), bg=self.bg_color, fg=self.fg_color).pack(anchor='w', pady=(0, 5))
        
        compresion_frame = tk.Frame(col_izq, bg=self.bg_color)
        compresion_frame.pack(fill='x', pady=(0, 10))
        
        self.scale_compresion = tk.Scale(compresion_frame, from_=0, to=9, orient='horizontal',
                                        variable=self.nivel_compresion,
                                        bg=self.bg_color, fg=self.fg_color,
                                        highlightthickness=0, length=200)
        self.scale_compresion.pack(side='left')
        
        tk.Label(compresion_frame, text="(0=Rápido, 9=Máximo)",
                font=('Segoe UI', 8), bg=self.bg_color, fg='#95a5a6').pack(side='left', padx=(10, 0))
        
        # Checkbox verificar integridad
        self.check_integridad = tk.Checkbutton(col_izq, 
                                              text="🔐 Verificar integridad (MD5)",
                                              variable=self.verificar_integridad,
                                              font=('Segoe UI', 10),
                                              bg=self.bg_color, fg=self.fg_color,
                                              selectcolor=self.bg_color,
                                              activebackground=self.bg_color,
                                              activeforeground=self.fg_color)
        self.check_integridad.pack(anchor='w', pady=(0, 5))
        
        # Checkbox crear log
        self.check_log = tk.Checkbutton(col_izq, 
                                       text="📝 Crear archivo de log",
                                       variable=self.crear_log,
                                       font=('Segoe UI', 10),
                                       bg=self.bg_color, fg=self.fg_color,
                                       selectcolor=self.bg_color,
                                       activebackground=self.bg_color,
                                       activeforeground=self.fg_color)
        self.check_log.pack(anchor='w', pady=(0, 10))
        
        # Columna derecha
        col_der = tk.Frame(columnas_frame, bg=self.bg_color)
        col_der.pack(side='right', fill='both', expand=True, padx=(20, 0))
        
        # Botones de utilidades
        tk.Button(col_der, text="🎯 Filtros Personalizados",
                 command=self.gestionar_filtros,
                 bg='#9b59b6', fg='white',
                 font=('Segoe UI', 9, 'bold'),
                 relief='flat', padx=15, pady=5).pack(fill='x', pady=(0, 5))
        
        tk.Button(col_der, text="📊 Analizar Carpeta",
                 command=self.analizar_carpeta,
                 bg='#e67e22', fg='white',
                 font=('Segoe UI', 9, 'bold'),
                 relief='flat', padx=15, pady=5).pack(fill='x', pady=(0, 5))
        
        tk.Button(col_der, text="🧹 Limpiar Temporales",
                 command=self.limpiar_temporales,
                 bg='#16a085', fg='white',
                 font=('Segoe UI', 9, 'bold'),
                 relief='flat', padx=15, pady=5).pack(fill='x')
    
    def crear_seccion_estadisticas(self, parent):
        """Crear sección de estadísticas en tiempo real"""
        stats_frame = tk.LabelFrame(parent, text="📈 Estadísticas",
                                   font=('Segoe UI', 12, 'bold'),
                                   bg=self.bg_color, fg=self.fg_color,
                                   bd=2, relief='groove')
        stats_frame.pack(fill='x', pady=(0, 15))
        
        # Frame para estadísticas en columnas
        stats_content = tk.Frame(stats_frame, bg=self.bg_color)
        stats_content.pack(fill='x', padx=10, pady=10)
        
        # Tiempo estimado
        tk.Label(stats_content, text="⏱️ Tiempo estimado:",
                font=('Segoe UI', 10), bg=self.bg_color, fg=self.fg_color).grid(row=0, column=0, sticky='w', padx=(0, 10))
        
        self.label_tiempo = tk.Label(stats_content, textvariable=self.tiempo_estimado,
                                    font=('Segoe UI', 10, 'bold'),
                                    bg=self.bg_color, fg='#f39c12')
        self.label_tiempo.grid(row=0, column=1, sticky='w')
        
        # Velocidad de procesamiento
        tk.Label(stats_content, text="🚀 Velocidad:",
                font=('Segoe UI', 10), bg=self.bg_color, fg=self.fg_color).grid(row=1, column=0, sticky='w', padx=(0, 10), pady=(5, 0))
        
        self.label_velocidad = tk.Label(stats_content, textvariable=self.velocidad_procesamiento,
                                       font=('Segoe UI', 10, 'bold'),
                                       bg=self.bg_color, fg='#27ae60')
        self.label_velocidad.grid(row=1, column=1, sticky='w', pady=(5, 0))
        
        # Información del sistema
        if PSUTIL_AVAILABLE:
            memoria_disponible = psutil.virtual_memory().available / (1024**3)  # GB
            memoria_text = f"💾 RAM disponible: {memoria_disponible:.1f} GB"
        else:
            memoria_text = "💾 RAM disponible: N/A"
            
        espacio_disco = shutil.disk_usage(os.path.expanduser('~')).free / (1024**3)  # GB
        
        tk.Label(stats_content, text=memoria_text,
                font=('Segoe UI', 9), bg=self.bg_color, fg='#95a5a6').grid(row=2, column=0, columnspan=2, sticky='w', pady=(10, 0))
        
        tk.Label(stats_content, text=f"💿 Espacio en disco: {espacio_disco:.1f} GB",
                font=('Segoe UI', 9), bg=self.bg_color, fg='#95a5a6').grid(row=3, column=0, columnspan=2, sticky='w')
    
    def crear_seccion_historial(self, parent):
        """Crear sección de historial de copias"""
        historial_frame = tk.LabelFrame(parent, text="📚 Historial de Copias Recientes",
                                       font=('Segoe UI', 12, 'bold'),
                                       bg=self.bg_color, fg=self.fg_color,
                                       bd=2, relief='groove')
        historial_frame.pack(fill='x', pady=(0, 15))
        
        # Frame con scroll para historial
        hist_scroll_frame = tk.Frame(historial_frame, bg=self.bg_color)
        hist_scroll_frame.pack(fill='both', expand=True, padx=10, pady=10)
        
        # Scrollbar para historial
        hist_scrollbar = tk.Scrollbar(hist_scroll_frame)
        hist_scrollbar.pack(side='right', fill='y')
        
        # Listbox para historial
        self.listbox_historial = tk.Listbox(hist_scroll_frame, 
                                            yscrollcommand=hist_scrollbar.set,
                                            font=('Consolas', 9),
                                            bg='#34495e', fg='white',
                                            selectbackground='#3498db',
                                            height=4)
        self.listbox_historial.pack(side='left', fill='both', expand=True)
        hist_scrollbar.config(command=self.listbox_historial.yview)
        
        # Botones para historial
        hist_botones = tk.Frame(historial_frame, bg=self.bg_color)
        hist_botones.pack(fill='x', padx=10, pady=(0, 10))
        
        tk.Button(hist_botones, text="🔄 Repetir Copia",
                 command=self.repetir_copia_seleccionada,
                 bg='#3498db', fg='white',
                 font=('Segoe UI', 9),
                 relief='flat', padx=10).pack(side='left', padx=(0, 5))
        
        tk.Button(hist_botones, text="📂 Abrir Ubicación",
                 command=self.abrir_ubicacion_historial,
                 bg='#f39c12', fg='white',
                 font=('Segoe UI', 9),
                 relief='flat', padx=10).pack(side='left', padx=(0, 5))
        
        tk.Button(hist_botones, text="🗑️ Limpiar Historial",
                 command=self.limpiar_historial,
                 bg='#e74c3c', fg='white',
                 font=('Segoe UI', 9),
                 relief='flat', padx=10).pack(side='right')
        
    def crear_seccion_progreso(self, parent):
        """Crear sección de progreso"""
        progress_frame = tk.LabelFrame(parent, text="📊 Progreso",
                                      font=('Segoe UI', 12, 'bold'),
                                      bg=self.bg_color, fg=self.fg_color,
                                      bd=2, relief='groove')
        progress_frame.pack(fill='x', pady=(0, 15))
        
        # Barra de progreso
        self.barra_progreso = ttk.Progressbar(progress_frame, 
                                             variable=self.progreso,
                                             maximum=100,
                                             length=400)
        self.barra_progreso.pack(fill='x', padx=10, pady=(10, 5))
        
        # Estado
        self.label_estado = tk.Label(progress_frame, textvariable=self.estado_texto,
                                    font=('Segoe UI', 10),
                                    bg=self.bg_color, fg='#95a5a6')
        self.label_estado.pack(padx=10, pady=(0, 15))
        
    def crear_botones(self, parent):
        """Crear botones de acción"""
        botones_frame = tk.Frame(parent, bg=self.bg_color)
        botones_frame.pack(fill='x', pady=10)
        
        # Botón crear copia
        self.btn_crear = tk.Button(botones_frame, text="🚀 Crear Copia de Seguridad",
                                  command=self.crear_copia_seguridad,
                                  bg='#27ae60', fg='white',
                                  font=('Segoe UI', 12, 'bold'),
                                  relief='flat', padx=30, pady=10)
        self.btn_crear.pack(side='left', padx=(0, 10))
        
        # Botón limpiar
        tk.Button(botones_frame, text="🧹 Limpiar Formulario",
                 command=self.limpiar_formulario,
                 bg='#e74c3c', fg='white',
                 font=('Segoe UI', 10, 'bold'),
                 relief='flat', padx=20, pady=10).pack(side='left')
        
        # Botón abrir destino
        tk.Button(botones_frame, text="📂 Abrir Destino",
                 command=self.abrir_carpeta_destino,
                 bg='#f39c12', fg='white',
                 font=('Segoe UI', 10, 'bold'),
                 relief='flat', padx=20, pady=10).pack(side='right')
        
    def seleccionar_origen(self):
        """Seleccionar carpeta de origen"""
        carpeta = filedialog.askdirectory(title="Seleccionar carpeta de origen")
        if carpeta:
            self.carpeta_origen.set(carpeta)
            self.estado_texto.set(f"📁 Carpeta origen seleccionada: {os.path.basename(carpeta)}")
            self.actualizar_nombre_archivo()
            self.detectar_tipo_proyecto(carpeta)
            self.guardar_configuracion()
    
    def actualizar_nombre_archivo(self):
        """Actualizar nombre del archivo basado en la carpeta origen"""
        if self.usar_nombre_carpeta.get() and self.carpeta_origen.get():
            nombre_carpeta = os.path.basename(self.carpeta_origen.get())
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            nuevo_nombre = f"{nombre_carpeta}_backup_{timestamp}"
            self.nombre_copia.set(nuevo_nombre)
            self.entry_nombre.config(state='disabled')
        else:
            self.entry_nombre.config(state='normal')
    
    def detectar_tipo_proyecto(self, carpeta):
        """Detectar si es un proyecto React u otro tipo"""
        archivos_react = ['package.json', 'src', 'public', 'node_modules']
        archivos_python = ['requirements.txt', 'setup.py', '__pycache__', 'venv']
        
        contenido = os.listdir(carpeta)
        
        if any(archivo in contenido for archivo in archivos_react):
            self.estado_texto.set("⚛️ Proyecto React detectado - Modo eficiente recomendado")
            self.modo_eficiente.set(True)
        elif any(archivo in contenido for archivo in archivos_python):
            self.estado_texto.set("🐍 Proyecto Python detectado - Modo eficiente recomendado")
            self.modo_eficiente.set(True)
        else:
            self.estado_texto.set("📁 Proyecto genérico detectado")
    
    def mostrar_exclusiones(self):
        """Mostrar ventana con las carpetas y archivos excluidos"""
        ventana_exclusiones = tk.Toplevel(self.root)
        ventana_exclusiones.title("Carpetas y archivos excluidos en modo eficiente")
        ventana_exclusiones.geometry("600x400")
        ventana_exclusiones.configure(bg=self.bg_color)
        
        # Título
        tk.Label(ventana_exclusiones, text="📋 Exclusiones en modo eficiente",
                font=('Segoe UI', 14, 'bold'),
                bg=self.bg_color, fg=self.fg_color).pack(pady=10)
        
        # Frame con scroll
        frame_scroll = tk.Frame(ventana_exclusiones, bg=self.bg_color)
        frame_scroll.pack(fill='both', expand=True, padx=20, pady=10)
        
        scrollbar = tk.Scrollbar(frame_scroll)
        scrollbar.pack(side='right', fill='y')
        
        listbox = tk.Listbox(frame_scroll, yscrollcommand=scrollbar.set,
                            font=('Consolas', 10),
                            bg='#34495e', fg='white',
                            selectbackground='#3498db')
        listbox.pack(side='left', fill='both', expand=True)
        scrollbar.config(command=listbox.yview)
        
        # Agregar exclusiones a la lista
        exclusiones_ordenadas = sorted(self.exclusiones_eficientes)
        for exclusion in exclusiones_ordenadas:
            listbox.insert(tk.END, f"  {exclusion}")
        
        # Botón cerrar
        tk.Button(ventana_exclusiones, text="Cerrar",
                 command=ventana_exclusiones.destroy,
                 bg='#e74c3c', fg='white',
                 font=('Segoe UI', 10, 'bold'),
                 relief='flat', padx=20, pady=5).pack(pady=10)
    
    def gestionar_filtros(self):
        """Gestionar filtros personalizados"""
        ventana_filtros = tk.Toplevel(self.root)
        ventana_filtros.title("Gestión de Filtros Personalizados")
        ventana_filtros.geometry("500x400")
        ventana_filtros.configure(bg=self.bg_color)
        
        # Título
        tk.Label(ventana_filtros, text="🎯 Filtros Personalizados",
                font=('Segoe UI', 14, 'bold'),
                bg=self.bg_color, fg=self.fg_color).pack(pady=10)
        
        # Frame para agregar filtro
        add_frame = tk.Frame(ventana_filtros, bg=self.bg_color)
        add_frame.pack(fill='x', padx=20, pady=10)
        
        tk.Label(add_frame, text="Agregar filtro (ej: *.tmp, cache, logs):",
                font=('Segoe UI', 10), bg=self.bg_color, fg=self.fg_color).pack(anchor='w')
        
        entry_filtro = tk.Entry(add_frame, font=('Segoe UI', 10), width=40)
        entry_filtro.pack(side='left', fill='x', expand=True, pady=(5, 0))
        
        def agregar_filtro():
            filtro = entry_filtro.get().strip()
            if filtro and filtro not in self.filtros_personalizados:
                self.filtros_personalizados.add(filtro)
                listbox_filtros.insert(tk.END, filtro)
                entry_filtro.delete(0, tk.END)
                self.guardar_configuracion()
        
        tk.Button(add_frame, text="➕ Agregar",
                 command=agregar_filtro,
                 bg='#27ae60', fg='white',
                 font=('Segoe UI', 9, 'bold'),
                 relief='flat', padx=10).pack(side='right', padx=(10, 0), pady=(5, 0))
        
        # Lista de filtros
        list_frame = tk.Frame(ventana_filtros, bg=self.bg_color)
        list_frame.pack(fill='both', expand=True, padx=20, pady=10)
        
        scrollbar_filtros = tk.Scrollbar(list_frame)
        scrollbar_filtros.pack(side='right', fill='y')
        
        listbox_filtros = tk.Listbox(list_frame, yscrollcommand=scrollbar_filtros.set,
                                    font=('Consolas', 10),
                                    bg='#34495e', fg='white',
                                    selectbackground='#3498db')
        listbox_filtros.pack(side='left', fill='both', expand=True)
        scrollbar_filtros.config(command=listbox_filtros.yview)
        
        # Cargar filtros existentes
        for filtro in sorted(self.filtros_personalizados):
            listbox_filtros.insert(tk.END, filtro)
        
        # Botones
        btn_frame = tk.Frame(ventana_filtros, bg=self.bg_color)
        btn_frame.pack(fill='x', padx=20, pady=10)
        
        def eliminar_filtro():
            seleccion = listbox_filtros.curselection()
            if seleccion:
                filtro = listbox_filtros.get(seleccion[0])
                self.filtros_personalizados.discard(filtro)
                listbox_filtros.delete(seleccion[0])
                self.guardar_configuracion()
        
        tk.Button(btn_frame, text="🗑️ Eliminar Seleccionado",
                 command=eliminar_filtro,
                 bg='#e74c3c', fg='white',
                 font=('Segoe UI', 9),
                 relief='flat', padx=10).pack(side='left')
        
        tk.Button(btn_frame, text="Cerrar",
                 command=ventana_filtros.destroy,
                 bg='#95a5a6', fg='white',
                 font=('Segoe UI', 9),
                 relief='flat', padx=10).pack(side='right')
    
    def analizar_carpeta(self):
        """Analizar carpeta para mostrar estadísticas"""
        if not self.carpeta_origen.get():
            messagebox.showwarning("Advertencia", "Seleccione primero una carpeta de origen")
            return
        
        ventana_analisis = tk.Toplevel(self.root)
        ventana_analisis.title("Análisis de Carpeta")
        ventana_analisis.geometry("600x500")
        ventana_analisis.configure(bg=self.bg_color)
        
        # Título
        tk.Label(ventana_analisis, text="📊 Análisis de Carpeta",
                font=('Segoe UI', 14, 'bold'),
                bg=self.bg_color, fg=self.fg_color).pack(pady=10)
        
        # Frame para resultados
        resultado_frame = tk.Frame(ventana_analisis, bg=self.bg_color)
        resultado_frame.pack(fill='both', expand=True, padx=20, pady=10)
        
        # Texto con scroll para mostrar resultados
        text_scroll = tk.Scrollbar(resultado_frame)
        text_scroll.pack(side='right', fill='y')
        
        text_resultado = tk.Text(resultado_frame, yscrollcommand=text_scroll.set,
                                font=('Consolas', 10),
                                bg='#34495e', fg='white',
                                wrap='word')
        text_resultado.pack(side='left', fill='both', expand=True)
        text_scroll.config(command=text_resultado.yview)
        
        def realizar_analisis():
            carpeta = self.carpeta_origen.get()
            text_resultado.delete(1.0, tk.END)
            text_resultado.insert(tk.END, "🔍 Analizando carpeta...\n\n")
            ventana_analisis.update()
            
            try:
                # Estadísticas básicas
                total_archivos = 0
                total_carpetas = 0
                tamaño_total = 0
                tipos_archivo = defaultdict(int)
                archivos_grandes = []
                
                # 🚀 USAR SISTEMA RADICAL ANTI-NUL para análisis
                def callback_analisis(mensaje):
                    pass  # Callback silencioso
                
                for root, dirs, files in os_walk_seguro(carpeta, callback_analisis):
                    total_carpetas += len(dirs)
                    for file in files:
                        total_archivos += 1
                        file_path = os.path.join(root, file)
                        try:
                            tamaño = os.path.getsize(file_path)
                            tamaño_total += tamaño
                            
                            # Tipo de archivo
                            ext = os.path.splitext(file)[1].lower()
                            tipos_archivo[ext if ext else 'sin extensión'] += 1
                            
                            # Archivos grandes (>10MB)
                            if tamaño > 10 * 1024 * 1024:
                                archivos_grandes.append((file, tamaño / (1024 * 1024)))
                        except:
                            continue
                
                # Mostrar resultados
                resultado = f"""📁 RESUMEN DEL ANÁLISIS
{'='*50}

📊 Estadísticas Generales:
• Total de archivos: {total_archivos:,}
• Total de carpetas: {total_carpetas:,}
• Tamaño total: {tamaño_total / (1024**3):.2f} GB

📋 Tipos de archivo más comunes:
"""
                
                # Top 10 tipos de archivo
                tipos_ordenados = sorted(tipos_archivo.items(), key=lambda x: x[1], reverse=True)[:10]
                for ext, count in tipos_ordenados:
                    resultado += f"• {ext}: {count:,} archivos\n"
                
                if archivos_grandes:
                    resultado += f"\n🔍 Archivos grandes (>10MB):\n"
                    archivos_grandes.sort(key=lambda x: x[1], reverse=True)
                    for nombre, tamaño_mb in archivos_grandes[:10]:
                        resultado += f"• {nombre}: {tamaño_mb:.1f} MB\n"
                
                # Estimación de compresión
                if self.modo_eficiente.get():
                    # 🚀 USAR SISTEMA RADICAL ANTI-NUL para contar exclusiones
                    archivos_excluidos = 0
                    try:
                        for root, dirs, files in os_walk_seguro(carpeta, callback_analisis):
                            for file in files:
                                try:
                                    if self.debe_excluir_archivo(os.path.join(root, file), carpeta):
                                        archivos_excluidos += 1
                                except:
                                    continue
                    except:
                        archivos_excluidos = 0
                    resultado += f"\n⚡ Modo eficiente:\n• Archivos que se excluirían: {archivos_excluidos:,}\n"
                
                text_resultado.delete(1.0, tk.END)
                text_resultado.insert(tk.END, resultado)
                
            except Exception as e:
                text_resultado.delete(1.0, tk.END)
                text_resultado.insert(tk.END, f"❌ Error durante el análisis: {str(e)}")
        
        # Realizar análisis en hilo separado
        threading.Thread(target=realizar_analisis, daemon=True).start()
        
        # Botón cerrar
        tk.Button(ventana_analisis, text="Cerrar",
                 command=ventana_analisis.destroy,
                 bg='#95a5a6', fg='white',
                 font=('Segoe UI', 10),
                 relief='flat', padx=20, pady=5).pack(pady=10)
    
    def limpiar_temporales(self):
        """Limpiar archivos temporales del sistema"""
        if not messagebox.askyesno("Confirmación", 
                                  "¿Desea limpiar archivos temporales del sistema?\n\n" +
                                  "Esto eliminará archivos en las carpetas temp del usuario."):
            return
        
        try:
            import tempfile
            temp_dir = tempfile.gettempdir()
            archivos_eliminados = 0
            
            # 🚀 USAR SISTEMA RADICAL ANTI-NUL para limpiar temporales
            def callback_limpieza(mensaje):
                pass  # Callback silencioso
            
            for root, dirs, files in os_walk_seguro(temp_dir, callback_limpieza):
                for file in files:
                    try:
                        file_path = os.path.join(root, file)
                        # Solo eliminar archivos antiguos (más de 1 día)
                        if time.time() - os.path.getmtime(file_path) > 86400:
                            os.remove(file_path)
                            archivos_eliminados += 1
                    except:
                        continue
            
            messagebox.showinfo("Limpieza completada", 
                               f"✅ Se eliminaron {archivos_eliminados} archivos temporales")
        except Exception as e:
            messagebox.showerror("Error", f"❌ Error durante la limpieza: {str(e)}")
    
    def repetir_copia_seleccionada(self):
        """Repetir una copia seleccionada del historial"""
        seleccion = self.listbox_historial.curselection()
        if not seleccion:
            messagebox.showwarning("Advertencia", "Seleccione una copia del historial")
            return
        
        indice = seleccion[0]
        if indice < len(self.historial_copias):
            copia = self.historial_copias[indice]
            self.carpeta_origen.set(copia['origen'])
            self.carpeta_destino.set(copia['destino'])
            self.actualizar_nombre_archivo()
            messagebox.showinfo("Configuración cargada", "✅ Configuración cargada desde el historial")
    
    def abrir_ubicacion_historial(self):
        """Abrir la ubicación de una copia del historial"""
        seleccion = self.listbox_historial.curselection()
        if not seleccion:
            messagebox.showwarning("Advertencia", "Seleccione una copia del historial")
            return
        
        indice = seleccion[0]
        if indice < len(self.historial_copias):
            copia = self.historial_copias[indice]
            if os.path.exists(copia['destino']):
                os.startfile(copia['destino'])
            else:
                messagebox.showerror("Error", "La carpeta de destino ya no existe")
    
    def limpiar_historial(self):
        """Limpiar el historial de copias"""
        if messagebox.askyesno("Confirmación", "¿Desea limpiar todo el historial?"):
            self.historial_copias.clear()
            self.listbox_historial.delete(0, tk.END)
            self.guardar_configuracion()
            messagebox.showinfo("Historial limpiado", "✅ Historial eliminado")
    
    def actualizar_historial(self):
        """Actualizar la visualización del historial"""
        self.listbox_historial.delete(0, tk.END)
        for copia in self.historial_copias[-10:]:  # Mostrar últimas 10
            fecha = copia['fecha']
            origen = os.path.basename(copia['origen'])
            tamaño = copia.get('tamaño', 'N/A')
            texto = f"{fecha} | {origen} | {tamaño}"
            self.listbox_historial.insert(0, texto)  # Insertar al inicio (más reciente arriba)
    
    def calcular_md5(self, archivo):
        """Calcular hash MD5 de un archivo"""
        hash_md5 = hashlib.md5()
        try:
            with open(archivo, "rb") as f:
                for chunk in iter(lambda: f.read(4096), b""):
                    hash_md5.update(chunk)
            return hash_md5.hexdigest()
        except:
            return None
            
    def seleccionar_destino(self):
        """Seleccionar carpeta de destino"""
        carpeta = filedialog.askdirectory(title="Seleccionar carpeta de destino")
        if carpeta:
            self.carpeta_destino.set(carpeta)
            self.guardar_configuracion()
            
    def debe_excluir_archivo(self, ruta_archivo, carpeta_origen):
        """Determinar si un archivo o carpeta debe ser excluido en modo eficiente"""
        if not self.modo_eficiente.get():
            return False
        
        ruta_relativa = os.path.relpath(ruta_archivo, carpeta_origen)
        partes_ruta = ruta_relativa.split(os.sep)
        nombre_archivo = os.path.basename(ruta_archivo).lower()
        
        # Verificar filtros personalizados primero
        for filtro in self.filtros_personalizados:
            if filtro.startswith('*.'):
                if nombre_archivo.endswith(filtro[1:]):
                    return True
            elif filtro.lower() in nombre_archivo or filtro.lower() in ruta_relativa.lower():
                return True
        
        # Verificar cada parte de la ruta
        for parte in partes_ruta:
            if parte in self.exclusiones_eficientes:
                return True
        
        # Verificar patrones de archivos
        for exclusion in self.exclusiones_eficientes:
            if '*' in exclusion:
                patron = exclusion.replace('*', '')
                if patron in nombre_archivo:
                    return True
        
        return False
    
    def crear_copia_seguridad(self):
        """Crear copia de seguridad en un hilo separado"""
        if not self.validar_datos():
            return
            
        # Deshabilitar botón
        self.btn_crear.configure(state='disabled')
        
        # Ejecutar en hilo separado
        thread = threading.Thread(target=self.proceso_copia_seguridad)
        thread.daemon = True
        thread.start()
        
    def proceso_copia_seguridad(self):
        """Proceso principal de copia de seguridad"""
        try:
            # Inicializar estadísticas
            self.tiempo_inicio = time.time()
            origen = self.carpeta_origen.get()
            destino = self.carpeta_destino.get()
            nombre = self.nombre_copia.get()
            incluir_ocultos = self.incluir_ocultos.get()
            
            # 🚨 CREAR LOG RADICAL PARA DEBUGGING 🚨
            log_radical_path = os.path.join(destino, f"LOG_RADICAL_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt")
            
            def log_radical(mensaje):
                """Función para logging radical con timestamp"""
                timestamp = datetime.now().strftime('%H:%M:%S.%f')[:-3]
                log_msg = f"[{timestamp}] {mensaje}"
                print(log_msg)
                try:
                    with open(log_radical_path, 'a', encoding='utf-8') as f:
                        f.write(log_msg + '\n')
                        f.flush()  # Forzar escritura inmediata
                except:
                    pass  # No fallar por problemas de log
            
            log_radical("🚀 INICIANDO SISTEMA RADICAL ANTI-NUL")
            log_radical(f"📁 Origen: {origen}")
            log_radical(f"📁 Destino: {destino}")
            
            # Limpiar lista de archivos problemáticos
            self.archivos_problematicos = []
            
            # VALIDACIÓN PREVIA DEL DIRECTORIO ORIGEN
            es_valido, razon_error = validar_directorio_origen(origen)
            if not es_valido:
                error_msg = f"Error en directorio origen: {razon_error}"
                self.root.after(0, lambda: messagebox.showerror("Error de Validación", error_msg))
                self.root.after(0, lambda: self.btn_crear.configure(state='normal'))
                return
            
            # Normalizar ruta de origen para uso seguro
            origen_seguro = obtener_ruta_segura(origen)
            
            # 🚨 INTERCEPTOR ULTRA-AGRESIVO PARA ERROR "NUL" 🚨
            log_radical("🔍 INTERCEPTOR RADICAL: Verificando directorio antes de cualquier operación...")
            self.root.after(0, lambda: self.estado_texto.set("🔍 INTERCEPTOR RADICAL: Verificando directorio..."))
            
            try:
                # Test básico de acceso al directorio
                log_radical(f"🧪 Probando acceso a: {origen_seguro}")
                test_items = os.listdir(origen_seguro)
                log_radical(f"✅ Directorio accesible, {len(test_items)} elementos encontrados")
                
                # Verificar si hay elementos con nombres reservados
                elementos_problematicos = []
                for item in test_items:
                    if es_nombre_reservado_windows(item.lower()):
                        elementos_problematicos.append(item)
                        log_radical(f"🚨 ELEMENTO PROBLEMÁTICO: {item}")
                
                if elementos_problematicos:
                    mensaje = f"⚠️  ELEMENTOS PROBLEMÁTICOS DETECTADOS: {', '.join(elementos_problematicos)}"
                    log_radical(mensaje)
                    self.root.after(0, lambda: self.estado_texto.set(mensaje))
                    
            except OSError as e:
                error_str = str(e).lower()
                log_radical(f"💥 ERROR CAPTURADO: {str(e)}")
                if 'nul' in error_str or 'mount' in error_str:
                    error_msg = f"🚫 ERROR NUL INTERCEPTADO: {str(e)}"
                    log_radical(error_msg)
                    log_radical(f"📄 Log guardado en: {log_radical_path}")
                    self.root.after(0, lambda: messagebox.showerror("Error NUL Interceptado", f"{error_msg}\n\nLog guardado en:\n{log_radical_path}"))
                    self.root.after(0, lambda: self.btn_crear.configure(state='normal'))
                    return
                else:
                    log_radical(f"🔄 Re-lanzando error no relacionado con NUL: {str(e)}")
                    raise  # Re-lanzar si no es el error que esperamos
            
            # Asegurar extensión .zip
            if not nombre.endswith('.zip'):
                nombre += '.zip'
                
            ruta_zip = os.path.join(destino, nombre)
            
            # Verificar si el archivo ya existe
            if os.path.exists(ruta_zip):
                respuesta = messagebox.askyesno(
                    "Archivo existente",
                    f"El archivo {nombre} ya existe. ¿Desea sobrescribirlo?"
                )
                if not respuesta:
                    self.root.after(0, lambda: self.btn_crear.configure(state='normal'))
                    return
                    
            modo_texto = "eficiente" if self.modo_eficiente.get() else "completo"
            self.root.after(0, lambda: self.estado_texto.set(f"📦 Preparando archivos en modo {modo_texto}..."))
            
            # Contar archivos para progreso (usar ruta segura)
            total_archivos = self.contar_archivos(origen_seguro, incluir_ocultos)
            archivos_procesados = 0
            archivos_excluidos = 0
            tamaño_total = 0
            archivos_verificados = []
            
            # Configurar compresión
            nivel_compresion = zipfile.ZIP_DEFLATED
            if self.nivel_compresion.get() >= 8:
                nivel_compresion = zipfile.ZIP_DEFLATED
            elif self.nivel_compresion.get() == 0:
                nivel_compresion = zipfile.ZIP_STORED
            
            with zipfile.ZipFile(ruta_zip, 'w', nivel_compresion, compresslevel=self.nivel_compresion.get()) as zipf:
                # CALLBACK PARA MOSTRAR ESTADO EN TIEMPO REAL
                def callback_estado_radical(mensaje):
                    # Actualizar interfaz en tiempo real
                    self.root.after(0, lambda: self.estado_texto.set(mensaje))
                
                # USAR OS_WALK_SEGURO RADICAL PARA MANEJAR ARCHIVOS PROBLEMÁTICOS
                try:
                    log_radical("🚀 Iniciando SISTEMA RADICAL ANTI-NUL...")
                    self.root.after(0, lambda: self.estado_texto.set("🚀 Iniciando SISTEMA RADICAL ANTI-NUL..."))
                    
                    # Crear función de callback que incluya log radical
                    def callback_completo(mensaje):
                        log_radical(f"📡 {mensaje}")
                        callback_estado_radical(mensaje)
                    
                    walk_iterator = os_walk_seguro(origen_seguro, callback_completo)
                except Exception as e:
                    # Fallback: intentar con ruta original si la segura falla
                    log_radical(f"⚠️  Error con ruta segura, intentando ruta original: {e}")
                    self.root.after(0, lambda: self.estado_texto.set(f"⚠️  Error con ruta segura, intentando ruta original..."))
                    try:
                        def callback_completo_fallback(mensaje):
                            log_radical(f"📡 FALLBACK: {mensaje}")
                            callback_estado_radical(mensaje)
                        
                        walk_iterator = os_walk_seguro(origen, callback_completo_fallback)
                    except Exception as e2:
                        error_msg = f"🚫 SISTEMA RADICAL FALLÓ: {str(e2)}"
                        log_radical(error_msg)
                        log_radical(f"📄 Log completo guardado en: {log_radical_path}")
                        self.root.after(0, lambda: messagebox.showerror("Error Crítico", f"{error_msg}\n\nLog completo guardado en:\n{log_radical_path}"))
                        self.root.after(0, lambda: self.btn_crear.configure(state='normal'))
                        return
                
                for root, dirs, files in walk_iterator:
                    # Filtrar carpetas ocultas si es necesario
                    if not incluir_ocultos:
                        dirs[:] = [d for d in dirs if not d.startswith('.')]
                        files = [f for f in files if not f.startswith('.')]
                    
                    # Filtrar carpetas excluidas en modo eficiente
                    if self.modo_eficiente.get():
                        dirs_filtrados = []
                        for d in dirs:
                            try:
                                ruta_dir = os.path.join(root, d)
                                if not self.debe_excluir_archivo(ruta_dir, origen):
                                    dirs_filtrados.append(d)
                                else:
                                    archivos_excluidos += 1
                            except Exception as e:
                                print(f"⚠️  Error procesando directorio {d}: {e}")
                                archivos_excluidos += 1
                        dirs[:] = dirs_filtrados
                    
                    for file in files:
                        file_path = None
                        try:
                            file_path = os.path.join(root, file)
                            
                            # Nota: os_walk_seguro ya filtró archivos problemáticos básicos,
                            # pero aún necesitamos validación adicional para acceso
                            try:
                                # Verificar acceso al archivo
                                if not os.path.exists(file_path):
                                    print(f"⚠️  Archivo no existe: {file}")
                                    archivos_excluidos += 1
                                    continue
                                    
                                if not os.access(file_path, os.R_OK):
                                    print(f"⚠️  Sin permisos de lectura: {file}")
                                    archivos_excluidos += 1
                                    continue
                            except Exception as e:
                                print(f"⚠️  Error verificando archivo {file}: {e}")
                                archivos_excluidos += 1
                                continue
                            
                            # Verificar exclusiones en modo eficiente
                            if self.modo_eficiente.get() and self.debe_excluir_archivo(file_path, origen):
                                archivos_excluidos += 1
                                continue
                            
                            # Obtener ruta segura para procesamiento
                            file_path_seguro = obtener_ruta_segura(file_path)
                            
                            # Verificación de integridad (calcular hash antes)
                            hash_original = None
                            if self.verificar_integridad.get():
                                try:
                                    hash_original = self.calcular_md5(file_path_seguro)
                                except Exception as e:
                                    self.archivos_problematicos.append({
                                        'archivo': file_path,
                                        'razon': f"Error calculando MD5: {str(e)}",
                                        'tipo': 'hash'
                                    })
                                    print(f"Error calculando hash para {file}: {e}")
                            
                            # Obtener tamaño del archivo de forma segura
                            try:
                                tamaño_archivo = os.path.getsize(file_path_seguro)
                                tamaño_total += tamaño_archivo
                            except Exception as e:
                                self.archivos_problematicos.append({
                                    'archivo': file_path,
                                    'razon': f"Error obteniendo tamaño: {str(e)}",
                                    'tipo': 'tamaño'
                                })
                                print(f"Error obteniendo tamaño de {file}: {e}")
                                continue
                            
                            # Guardar info para verificación
                            if hash_original:
                                archivos_verificados.append({
                                    'archivo': os.path.relpath(file_path, origen),
                                    'hash': hash_original,
                                    'tamaño': tamaño_archivo
                                })
                            
                            # Crear nombre de archivo seguro para el ZIP
                            arcname = os.path.relpath(file_path, origen)
                            nombre_archivo_zip = sanitizar_nombre_archivo(os.path.basename(arcname))
                            arcname_seguro = os.path.join(os.path.dirname(arcname), nombre_archivo_zip).replace('\\', '/')
                            
                            # Escribir archivo al ZIP de forma segura
                            try:
                                zipf.write(file_path_seguro, arcname_seguro)
                                archivos_procesados += 1
                            except Exception as e:
                                self.archivos_problematicos.append({
                                    'archivo': file_path,
                                    'razon': f"Error escribiendo al ZIP: {str(e)}",
                                    'tipo': 'zip'
                                })
                                print(f"Error escribiendo {file} al ZIP: {e}")
                                continue
                            
                            # Actualizar estadísticas en tiempo real
                            tiempo_transcurrido = time.time() - self.tiempo_inicio
                            if tiempo_transcurrido > 0:
                                velocidad = archivos_procesados / tiempo_transcurrido
                                tiempo_restante = (total_archivos - archivos_procesados) / velocidad if velocidad > 0 else 0
                                
                                self.root.after(0, lambda tr=tiempo_restante: self.tiempo_estimado.set(f"{tr:.0f}s"))
                                self.root.after(0, lambda v=velocidad: self.velocidad_procesamiento.set(f"{v:.1f} archivos/s"))
                            
                            progreso = (archivos_procesados / total_archivos) * 100
                            
                            self.root.after(0, lambda p=progreso: self.progreso.set(p))
                            self.root.after(0, lambda: self.estado_texto.set(
                                f"📦 Procesando: {archivos_procesados}/{total_archivos} archivos"))
                                
                        except Exception as e:
                            # Manejo de errores generales
                            archivo_error = file_path if file_path else f"archivo desconocido en {root}"
                            self.archivos_problematicos.append({
                                'archivo': archivo_error,
                                'razon': f"Error general: {str(e)}",
                                'tipo': 'general'
                            })
                            print(f"Error general procesando {file}: {e}")
                            continue
            
            # Crear log si está habilitado
            if self.crear_log.get():
                self.crear_archivo_log(ruta_zip, archivos_procesados, tamaño_total, archivos_verificados, archivos_excluidos)
            
            # Agregar al historial
            entrada_historial = {
                'fecha': time.strftime('%Y-%m-%d %H:%M'),
                'origen': origen,
                'destino': ruta_zip,
                'archivos': archivos_procesados,
                'tamaño': f"{tamaño_total / (1024**2):.1f} MB"
            }
            self.historial_copias.append(entrada_historial)
            self.actualizar_historial()
            
            # Completado
            tiempo_total = time.time() - self.tiempo_inicio
            tamaño = os.path.getsize(ruta_zip) / (1024 * 1024)  # MB
            mensaje = f"✅ Copia creada exitosamente\n\nArchivo: {nombre}\nTamaño: {tamaño:.1f} MB\nArchivos: {archivos_procesados}\nTiempo: {tiempo_total:.1f}s"
            if self.modo_eficiente.get():
                mensaje += f"\nElementos excluidos: {archivos_excluidos}"
            
            # Agregar información sobre archivos problemáticos
            if self.archivos_problematicos:
                mensaje += f"\n⚠️ Archivos problemáticos saltados: {len(self.archivos_problematicos)}"
                mensaje += "\n(Ver log para detalles)"
            
            self.root.after(0, lambda: self.estado_texto.set("✅ Copia de seguridad completada"))
            self.root.after(0, lambda: messagebox.showinfo("Éxito", mensaje))
            
        except Exception as e:
            error_msg = f"❌ Error al crear la copia: {str(e)}"
            self.root.after(0, lambda: self.estado_texto.set(error_msg))
            self.root.after(0, lambda: messagebox.showerror("Error", error_msg))
            
        finally:
            self.root.after(0, lambda: self.btn_crear.configure(state='normal'))
    
    def crear_archivo_log(self, ruta_zip, archivos_procesados, tamaño_total, archivos_verificados, archivos_excluidos):
        """SISTEMA DE LOGGING ULTRA-DETALLADO para archivos problemáticos"""
        try:
            log_path = ruta_zip.replace('.zip', '_log_detallado.txt')
            with open(log_path, 'w', encoding='utf-8') as log_file:
                log_file.write(f"🛡️  === LOG ULTRA-DETALLADO DE COPIA DE SEGURIDAD ===\n")
                log_file.write(f"📅 Fecha: {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
                log_file.write(f"📦 Archivo ZIP: {os.path.basename(ruta_zip)}\n")
                log_file.write(f"📂 Origen: {self.carpeta_origen.get()}\n")
                log_file.write(f"✅ Archivos procesados: {archivos_procesados}\n")
                log_file.write(f"⚠️  Archivos excluidos (modo eficiente): {archivos_excluidos}\n")
                log_file.write(f"🚫 Archivos problemáticos detectados: {len(self.archivos_problematicos)}\n")
                log_file.write(f"💾 Tamaño total: {tamaño_total / (1024**2):.2f} MB\n")
                log_file.write(f"⚡ Modo eficiente: {'Sí' if self.modo_eficiente.get() else 'No'}\n")
                log_file.write(f"🔍 Verificación de integridad: {'Sí' if self.verificar_integridad.get() else 'No'}\n")
                log_file.write(f"🗜️  Nivel de compresión: {self.nivel_compresion.get()}\n")
                log_file.write(f"🛡️  Sistema de protección: ULTRA-ROBUSTO activado\n\n")
                
                # SECCIÓN CRÍTICA: ARCHIVOS PROBLEMÁTICOS DETECTADOS
                if self.archivos_problematicos:
                    log_file.write("🚨 === ARCHIVOS PROBLEMÁTICOS CRÍTICOS DETECTADOS ===\n")
                    log_file.write("⚠️  Los siguientes archivos fueron AUTOMÁTICAMENTE SALTADOS para evitar errores:\n")
                    log_file.write("🛡️  Sistema de protección ULTRA-ROBUSTO activado con éxito.\n\n")
                    
                    # Agrupar por tipo de problema con emojis y descripciones detalladas
                    problemas_por_tipo = {}
                    for problema in self.archivos_problematicos:
                        tipo = problema['tipo']
                        if tipo not in problemas_por_tipo:
                            problemas_por_tipo[tipo] = []
                        problemas_por_tipo[tipo].append(problema)
                    
                    # Mapeo de tipos a descripciones y emojis
                    tipo_descripciones = {
                        'nombre_reservado_critico': ('🚫 NOMBRES RESERVADOS DE WINDOWS', 'Archivos con nombres que Windows no puede procesar (nul, con, prn, aux, etc.)'),
                        'caracteres_criticos': ('⚠️  CARACTERES PROBLEMÁTICOS', 'Archivos con caracteres especiales que causan errores'),
                        'ruta_critica': ('📏 RUTAS EXTREMADAMENTE LARGAS', 'Archivos con rutas que exceden los límites de Windows'),
                        'formato_critico': ('🔤 FORMATO PROBLEMÁTICO', 'Archivos con espacios/puntos al inicio/final del nombre'),
                        'nombre_vacio': ('❌ NOMBRES VACÍOS', 'Archivos con nombres vacíos o solo espacios'),
                        'hash': ('🔍 ERROR DE HASH', 'Error calculando verificación de integridad'),
                        'tamaño': ('📊 ERROR DE TAMAÑO', 'Error obteniendo información del archivo'),
                        'zip': ('📦 ERROR DE COMPRESIÓN', 'Error escribiendo archivo al ZIP'),
                        'general': ('⚠️  ERROR GENERAL', 'Otros errores durante el procesamiento')
                    }
                    
                    for tipo, problemas in problemas_por_tipo.items():
                        emoji, descripcion = tipo_descripciones.get(tipo, ('❓', 'Tipo de error desconocido'))
                        log_file.write(f"\n{emoji} --- {descripcion} ({len(problemas)} archivos) ---\n")
                        log_file.write(f"📝 Descripción: {descripcion}\n\n")
                        
                        for i, problema in enumerate(problemas, 1):
                            log_file.write(f"   {i}. 📄 Archivo: {problema['archivo']}\n")
                            log_file.write(f"      🔍 Razón específica: {problema['razon']}\n")
                            log_file.write(f"      🏷️  Tipo de problema: {tipo}\n")
                            if 'ruta' in problema:
                                log_file.write(f"      📍 Ruta completa: {problema['ruta']}\n")
                            log_file.write(f"      ✅ Estado: SALTADO AUTOMÁTICAMENTE (sin interrumpir el backup)\n\n")
                
                # SECCIÓN DE ESTADÍSTICAS AVANZADAS
                log_file.write("📊 === ESTADÍSTICAS AVANZADAS ===\n")
                total_items = archivos_procesados + archivos_excluidos + len(self.archivos_problematicos)
                if total_items > 0:
                    porcentaje_exitoso = (archivos_procesados / total_items) * 100
                    porcentaje_excluido = (archivos_excluidos / total_items) * 100
                    porcentaje_problematico = (len(self.archivos_problematicos) / total_items) * 100
                    
                    log_file.write(f"📈 Total de elementos analizados: {total_items}\n")
                    log_file.write(f"✅ Procesados exitosamente: {archivos_procesados} ({porcentaje_exitoso:.1f}%)\n")
                    log_file.write(f"⚠️  Excluidos (modo eficiente): {archivos_excluidos} ({porcentaje_excluido:.1f}%)\n")
                    log_file.write(f"🚫 Problemáticos saltados: {len(self.archivos_problematicos)} ({porcentaje_problematico:.1f}%)\n")
                    log_file.write(f"🛡️  Eficacia del sistema de protección: {100 - porcentaje_problematico:.1f}%\n\n")
                
                # SECCIÓN DE RECOMENDACIONES
                if self.archivos_problematicos:
                    log_file.write("💡 === RECOMENDACIONES ===\n")
                    log_file.write("🔧 Para resolver los archivos problemáticos detectados:\n\n")
                    
                    if any(p['tipo'] == 'nombre_reservado_critico' for p in self.archivos_problematicos):
                        log_file.write("🚫 NOMBRES RESERVADOS:\n")
                        log_file.write("   • Renombre archivos con nombres como 'nul', 'con', 'prn', 'aux'\n")
                        log_file.write("   • Evite usar nombres de dispositivos de Windows\n\n")
                    
                    if any(p['tipo'] == 'caracteres_criticos' for p in self.archivos_problematicos):
                        log_file.write("⚠️  CARACTERES PROBLEMÁTICOS:\n")
                        log_file.write("   • Elimine caracteres especiales: < > : \" | ? *\n")
                        log_file.write("   • Use solo letras, números, guiones y puntos\n\n")
                    
                    if any(p['tipo'] == 'ruta_critica' for p in self.archivos_problematicos):
                        log_file.write("📏 RUTAS LARGAS:\n")
                        log_file.write("   • Mueva archivos a carpetas con nombres más cortos\n")
                        log_file.write("   • Reorganice la estructura de directorios\n\n")
                    
                    log_file.write("✅ RESULTADO: El backup se completó exitosamente saltando automáticamente los archivos problemáticos.\n")
                    log_file.write("🛡️  El sistema de protección ULTRA-ROBUSTO funcionó correctamente.\n\n")
                
                # Verificación de integridad (si está habilitada)
                if archivos_verificados:
                    log_file.write("🔍 === VERIFICACIÓN DE INTEGRIDAD ===\n")
                    log_file.write("📋 Hashes MD5 de archivos verificados:\n\n")
                    for archivo_info in archivos_verificados:
                        log_file.write(f"📄 {archivo_info['archivo']}\n")
                        log_file.write(f"   🔐 Hash: {archivo_info['hash']}\n")
                        log_file.write(f"   📊 Tamaño: {archivo_info['tamaño']} bytes\n\n")
                
                log_file.write("🎉 === BACKUP COMPLETADO EXITOSAMENTE ===\n")
                log_file.write("✅ El sistema de protección ULTRA-ROBUSTO garantizó un backup sin errores.\n")
                log_file.write("🛡️  Todos los archivos problemáticos fueron detectados y saltados automáticamente.\n")
                
        except Exception as e:
            print(f"❌ Error creando log detallado: {e}")
            # Crear log básico como fallback
            try:
                log_path_basico = ruta_zip.replace('.zip', '_log_basico.txt')
                with open(log_path_basico, 'w', encoding='utf-8') as log_basico:
                    log_basico.write(f"LOG BÁSICO - Error en log detallado: {e}\n")
                    log_basico.write(f"Archivos procesados: {archivos_procesados}\n")
                    log_basico.write(f"Archivos problemáticos: {len(self.archivos_problematicos)}\n")
            except:
                pass
            
    def contar_archivos(self, ruta, incluir_ocultos):
        """🚀 VERSIÓN RADICAL: Contar archivos usando sistema seguro anti-NUL"""
        total = 0
        
        def callback_contador(mensaje):
            # Callback silencioso para el contador
            pass
        
        try:
            # USAR SISTEMA RADICAL ANTI-NUL para contar archivos
            for root, dirs, files in os_walk_seguro(ruta, callback_contador):
                if not incluir_ocultos:
                    dirs[:] = [d for d in dirs if not d.startswith('.')]
                    files = [f for f in files if not f.startswith('.')]
                
                # Filtrar carpetas excluidas en modo eficiente
                if self.modo_eficiente.get():
                    dirs_filtrados = []
                    for d in dirs:
                        try:
                            dir_path = os.path.join(root, d)
                            if not self.debe_excluir_archivo(dir_path, ruta):
                                dirs_filtrados.append(d)
                        except Exception:
                            # Saltar directorios problemáticos
                            continue
                    dirs[:] = dirs_filtrados
                
                # Contar solo archivos no excluidos y válidos
                for file in files:
                    try:
                        file_path = os.path.join(root, file)
                        
                        # Verificar exclusiones en modo eficiente
                        if self.modo_eficiente.get() and self.debe_excluir_archivo(file_path, ruta):
                            continue
                        
                        # Verificar si el archivo es válido para procesar
                        es_valido, _ = validar_ruta_archivo(file_path)
                        if es_valido:
                            total += 1
                    except Exception:
                        # Saltar archivos problemáticos
                        continue
                        
        except Exception as e:
            print(f"⚠️  Error contando archivos (usando fallback): {e}")
            # Fallback: devolver estimación conservadora
            try:
                items = os.listdir(ruta)
                total = len([item for item in items if os.path.isfile(os.path.join(ruta, item))])
            except:
                total = 100  # Estimación por defecto
                
        return total
        
    def validar_datos(self):
        """Validar que todos los datos necesarios estén completos"""
        if not self.carpeta_origen.get():
            messagebox.showerror("Error", "❌ Debe seleccionar una carpeta de origen")
            return False
            
        if not self.carpeta_destino.get():
            messagebox.showerror("Error", "❌ Debe seleccionar una carpeta de destino")
            return False
            
        if not self.nombre_copia.get():
            messagebox.showerror("Error", "❌ Debe especificar un nombre para la copia")
            return False
            
        if not os.path.exists(self.carpeta_origen.get()):
            messagebox.showerror("Error", "❌ La carpeta de origen no existe")
            return False
            
        if not os.path.exists(self.carpeta_destino.get()):
            messagebox.showerror("Error", "❌ La carpeta de destino no existe")
            return False
            
        return True
        
    def limpiar_formulario(self):
        """Limpiar todos los campos del formulario"""
        self.carpeta_origen.set("")
        self.carpeta_destino.set("")
        self.nombre_copia.set(f"backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
        self.incluir_ocultos.set(False)
        self.modo_eficiente.set(True)
        self.usar_nombre_carpeta.set(True)
        self.progreso.set(0)
        self.estado_texto.set("✨ Formulario limpiado - Listo para nueva copia")
        
        # Habilitar campo de nombre y botón crear
        self.entry_nombre.config(state='normal')
        self.btn_crear.configure(state='normal')
        
        self.guardar_configuracion()
        messagebox.showinfo("Limpieza completada", "Todos los campos han sido limpiados")
        
        # Actualizar estado después de un momento
        self.root.after(2000, lambda: self.estado_texto.set("✨ Listo para crear copia de seguridad"))
        
    def abrir_carpeta_destino(self):
        """Abrir la carpeta de destino en el explorador"""
        if self.carpeta_destino.get() and os.path.exists(self.carpeta_destino.get()):
            os.startfile(self.carpeta_destino.get())
        else:
            messagebox.showwarning("Advertencia", "❌ No hay carpeta de destino seleccionada o no existe")
            
    def centrar_ventana(self):
        """Centrar la ventana en la pantalla"""
        self.root.update_idletasks()
        width = self.root.winfo_width()
        height = self.root.winfo_height()
        x = (self.root.winfo_screenwidth() // 2) - (width // 2)
        y = (self.root.winfo_screenheight() // 2) - (height // 2)
        self.root.geometry(f'{width}x{height}+{x}+{y}')
        
    def cargar_configuracion(self):
        """Cargar configuración guardada"""
        try:
            config_file = 'backup_config.json'
            if os.path.exists(config_file):
                with open(config_file, 'r', encoding='utf-8') as f:
                    config = json.load(f)
                    self.carpeta_origen.set(config.get('carpeta_origen', ''))
                    self.carpeta_destino.set(config.get('carpeta_destino', ''))
                    self.incluir_ocultos.set(config.get('incluir_ocultos', False))
                    self.modo_eficiente.set(config.get('modo_eficiente', True))
                    self.usar_nombre_carpeta.set(config.get('usar_nombre_carpeta', True))
                    self.verificar_integridad.set(config.get('verificar_integridad', False))
                    self.nivel_compresion.set(config.get('nivel_compresion', 6))
                    self.crear_log.set(config.get('crear_log', False))
                    
                    # Cargar filtros personalizados
                    filtros_guardados = config.get('filtros_personalizados', [])
                    self.filtros_personalizados = set(filtros_guardados)
                    
                    # Cargar historial
                    self.historial_copias = config.get('historial_copias', [])
                    if hasattr(self, 'listbox_historial'):
                        self.actualizar_historial()
                    
                    # Actualizar estado del campo nombre si está configurado para usar nombre automático
                    self.actualizar_nombre_archivo()
        except Exception as e:
            print(f"Error cargando configuración: {e}")
            
    def guardar_configuracion(self):
        """Guardar configuración actual"""
        try:
            config = {
                'carpeta_origen': self.carpeta_origen.get(),
                'carpeta_destino': self.carpeta_destino.get(),
                'incluir_ocultos': self.incluir_ocultos.get(),
                'modo_eficiente': self.modo_eficiente.get(),
                'usar_nombre_carpeta': self.usar_nombre_carpeta.get(),
                'verificar_integridad': self.verificar_integridad.get(),
                'nivel_compresion': self.nivel_compresion.get(),
                'crear_log': self.crear_log.get(),
                'filtros_personalizados': list(self.filtros_personalizados),
                'historial_copias': self.historial_copias[-50:] if hasattr(self, 'historial_copias') else []
            }
            with open('backup_config.json', 'w', encoding='utf-8') as f:
                json.dump(config, f, indent=2, ensure_ascii=False)
        except Exception as e:
            print(f"Error guardando configuración: {e}")

def main():
    """Función principal"""
    root = tk.Tk()
    app = CopyNestApp(root)
    root.mainloop()

if __name__ == "__main__":
    main()