#!/usr/bin/env python3
"""
Script de limpieza para HokoriTemp
Elimina archivos expirados de la base de datos y del sistema de archivos
"""

import os
import sys
from datetime import datetime
from database import cleanup_expired_files, get_all_files, hard_delete_file

def cleanup_physical_files(upload_folder='uploads'):
    """Eliminar archivos físicos que ya no están en la base de datos"""
    if not os.path.exists(upload_folder):
        print(f"La carpeta {upload_folder} no existe.")
        return
    
    # Obtener todos los archivos en la base de datos
    db_files = get_all_files()
    db_filenames = {file['stored_filename'] for file in db_files}
    
    # Obtener todos los archivos físicos
    physical_files = os.listdir(upload_folder)
    
    # Encontrar archivos huérfanos (físicos pero no en BD)
    orphaned_files = []
    for filename in physical_files:
        if filename not in db_filenames:
            orphaned_files.append(filename)
    
    # Eliminar archivos huérfanos
    deleted_count = 0
    for filename in orphaned_files:
        file_path = os.path.join(upload_folder, filename)
        try:
            os.remove(file_path)
            deleted_count += 1
            print(f"Eliminado archivo huérfano: {filename}")
        except Exception as e:
            print(f"Error eliminando {filename}: {e}")
    
    print(f"Se eliminaron {deleted_count} archivos huérfanos.")

def cleanup_expired_from_db():
    """Limpiar archivos expirados de la base de datos permanentemente"""
    try:
        from database import get_active_files, hard_delete_file
        import os
        
        # Obtener archivos activos (no expirados)
        active_files = get_active_files()
        active_file_ids = {file['id'] for file in active_files}
        
        # Obtener todos los archivos
        all_files = get_all_files()
        
        # Encontrar archivos expirados
        expired_files = []
        for file in all_files:
            if file['id'] not in active_file_ids:
                expired_files.append(file)
        
        # Eliminar archivos expirados permanentemente
        deleted_count = 0
        for file in expired_files:
            try:
                # Eliminar archivo físico
                file_path = os.path.join('uploads', file['stored_filename'])
                if os.path.exists(file_path):
                    os.remove(file_path)
                
                # Eliminar de la base de datos
                hard_delete_file(file['id'])
                deleted_count += 1
                print(f"Eliminado archivo expirado: {file['original_filename']}")
            except Exception as e:
                print(f"Error eliminando archivo expirado {file['original_filename']}: {e}")
        
        print(f"Se eliminaron permanentemente {deleted_count} archivos expirados.")
        return deleted_count
    except Exception as e:
        print(f"Error limpiando base de datos: {e}")
        return 0

def get_stats():
    """Mostrar estadísticas de la base de datos"""
    try:
        from database import get_file_stats
        stats = get_file_stats()
        print(f"\nEstadísticas:")
        print(f"- Total de archivos: {stats['total_files']}")
        print(f"- Archivos activos: {stats['active_files']}")
        print(f"- Total de descargas: {stats['total_downloads']}")
    except Exception as e:
        print(f"Error obteniendo estadísticas: {e}")

def main():
    """Función principal del script de limpieza"""
    print("=== HokoriTemp - Script de Limpieza ===")
    
    # Verificar argumentos
    if len(sys.argv) > 1:
        command = sys.argv[1]
        
        if command == '--help' or command == '-h':
            print("""
Uso: python cleanup.py [comando]

Comandos disponibles:
  --help, -h     Mostrar esta ayuda
  --stats        Mostrar estadísticas de la base de datos
  --db-only      Solo limpiar base de datos (no archivos físicos)
  --files-only   Solo limpiar archivos físicos huérfanos
  --all          Limpiar todo (por defecto)

Ejemplos:
  python cleanup.py --stats
  python cleanup.py --db-only
  python cleanup.py --all
            """)
            return
        
        elif command == '--stats':
            get_stats()
            return
        
        elif command == '--db-only':
            print("Limpiando solo base de datos...")
            cleanup_expired_from_db()
            return
        
        elif command == '--files-only':
            print("Limpiando solo archivos físicos...")
            cleanup_physical_files()
            return
    
    # Limpieza completa por defecto
    print("Iniciando limpieza completa...")
    
    # Limpiar base de datos
    db_deleted = cleanup_expired_from_db()
    
    # Limpiar archivos físicos
    cleanup_physical_files()
    
    # Mostrar estadísticas finales
    get_stats()
    
    print("\nLimpieza completada.")

if __name__ == '__main__':
    main()