#!/bin/bash
# migration_verification.sh - Verificación completa de migración

echo "🔍 VERIFICACIÓN INTEGRAL DE MIGRACIÓN A PRIVACIDAD DIGITAL"
echo "=============================================================="

# Colores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Contadores para la puntuación
ok_count=0
warning_count=0
error_count=0
total_checks=0

# Función para verificar servicios
check_service() {
    local service=$1
    local status=$2
    total_checks=$((total_checks + 1))
    
    if [ "$status" = "ok" ]; then
        echo -e "✅ ${GREEN}$service${NC}"
        ok_count=$((ok_count + 1))
    elif [ "$status" = "warning" ]; then
        echo -e "⚠️  ${YELLOW}$service${NC}"
        warning_count=$((warning_count + 1))
    else
        echo -e "❌ ${RED}$service${NC}"
        error_count=$((error_count + 1))
    fi
}

# Función para manejar las preguntas
ask_question() {
    local question=$1
    local service_name=$2
    local ok_status=${3:-ok} # Default success status is 'ok'
    local fail_status=${4:-error} # Default fail status is 'error'
    local answer

    read -p "$question (y/n): " answer
    # Convertir a minúsculas para aceptar 'y' o 'Y'
    answer=$(echo "$answer" | tr '[:upper:]' '[:lower:]')

    if [ "$answer" = "y" ]; then
        check_service "$service_name" "$ok_status"
    else
        check_service "$service_name" "$fail_status"
    fi
}

echo ""
echo "📧 CORREO ELECTRÓNICO:"
ask_question "¿Proton Mail configurado y funcionando?" "Proton Mail configurado"
ask_question "¿Contactos importados correctamente?" "Contactos migrados"
ask_question "¿Forwarding de Gmail activo?" "Gmail forwarding activo" "warning" "ok" # Lógica invertida: 'y' es advertencia

echo ""
echo "📅 CALENDARIO Y ORGANIZACIÓN:"
ask_question "¿Proton Calendar sincronizado en dispositivos?" "Calendario sincronizado"
ask_question "¿Obsidian Vault funcionando correctamente?" "Obsidian Vault operativo"

echo ""
echo "💾 ALMACENAMIENTO Y DOCUMENTOS:"
ask_question "¿Proton Drive con documentos críticos?" "Proton Drive configurado"
ask_question "¿LibreOffice instalado y funcional?" "LibreOffice operativo"
ask_question "¿CryptPad para colaboración configurado?" "CryptPad colaborativo" "ok" "warning"

echo ""
echo "📸 FOTOS Y MULTIMEDIA:"
ask_question "¿Fotos migradas a Ente.io u otra alternativa?" "Fotos migradas"
ask_question "¿Google Photos vacío o eliminado?" "Google Photos limpio" "ok" "warning"

echo ""
echo "🔐 SEGURIDAD:"
ask_question "¿Bitwarden configurado con contraseñas migradas?" "Bitwarden operativo"
ask_question "¿2FA configurado con Aegis/Authy?" "2FA configurado"
ask_question "¿ProtonVPN instalado y funcional?" "ProtonVPN activo" "ok" "warning"

echo ""
echo "🌐 NAVEGACIÓN Y COMUNICACIÓN:"
ask_question "¿Firefox configurado con extensiones de privacidad?" "Firefox privado configurado"
ask_question "¿Signal instalado y contactos notificados?" "Signal configurado" "ok" "warning"
ask_question "¿NewPipe/Invidious configurado para YouTube?" "YouTube alternativas" "ok" "warning"

echo ""
echo "🗺️ MAPAS Y BÚSQUEDA:"
ask_question "¿Organic Maps instalado con lugares migrados?" "Mapas privados configurados" "ok" "warning"
ask_question "¿DuckDuckGo como buscador predeterminado?" "Buscador privado activo" "ok" "warning"

echo ""
echo "💾 BACKUPS Y SEGURIDAD:"
ask_question "¿Backups locales cifrados configurados?" "Backups cifrados activos"
ask_question "¿Datos sensibles eliminados de Google?" "Limpieza Google completada" "ok" "warning"

echo ""
echo "=============================================================="
echo "🎯 PUNTUACIÓN DE MIGRACIÓN:"

# Calcular puntuación (basada en elementos OK sobre el total)
score=0
if [ $total_checks -gt 0 ]; then
    score=$((100 * ok_count / total_checks))
fi

echo -e "Progreso de migración: ${GREEN}$ok_count OK${NC}, ${YELLOW}$warning_count Advertencias${NC}, ${RED}$error_count Errores${NC}."
echo "📊 Puntuación de completitud: $score%"
echo ""
echo "📋 PRÓXIMOS PASOS RECOMENDADOS:"
if [ $error_count -gt 0 ]; then
    echo "1. Completar elementos faltantes marcados con (❌)."
fi
if [ $warning_count -gt 0 ]; then
    echo "2. Revisar elementos con advertencias (⚠️) para asegurar que la configuración es la deseada."  
fi
echo "3. Configurar backups automáticos si aún no lo has hecho."
echo "4. Programar una revisión mensual de tu configuración de privacidad."

#!/bin/bash
# linux_privacy_check.sh

echo "🐧 LINUX PRIVACY SETUP VERIFICATION"

# Verificar software esencial instalado
check_installed() {
    if command -v $1 &> /dev/null; then
        echo "✅ $1 instalado"
    else
        echo "❌ $1 NO encontrado"
    fi
}

echo "📧 Email & PIM:"
check_installed "thunderbird"
check_installed "evolution"

echo "📝 Productivity:"
check_installed "obsidian"
check_installed "libreoffice"

echo "🔐 Security:"
check_installed "bitwarden"
check_installed "veracrypt"
check_installed "protonvpn"

echo "🌐 Browsing:"
check_installed "firefox"

echo "📸 Media:"
check_installed "digikam"

# Verificar servicios activos
echo "🔄 Services Status:"
systemctl --user is-active protonmail-bridge && echo "✅ Proton Bridge activo" || echo "⚠️  Proton Bridge inactivo"

# Verificar configuraciones de privacidad Firefox
FIREFOX_PROFILE=$(find ~/.mozilla/firefox -name "*.default*" -type d | head -1)
if [ -d "$FIREFOX_PROFILE" ]; then
    echo "✅ Perfil Firefox encontrado: $(basename "$FIREFOX_PROFILE")"
    
    # Verificar extensiones críticas
    if grep -q "[email protected]" "$FIREFOX_PROFILE/extensions.json" 2>/dev/null; then
        echo "✅ uBlock Origin instalado"
    else
        echo "❌ uBlock Origin faltante"
    fi
fi

echo "💾 Backup Status:"
if [ -f "/etc/cron.d/privacy-backup" ]; then
    echo "✅ Backup automático configurado"
else
    echo "⚠️  Configurar backup automático recomendado"
fi

#!/bin/bash
# comprehensive_backup.sh - Backup completo de migración privacidad

# Configuración
BACKUP_BASE="/media/external-backup"  # Cambiar por tu dispositivo de backup
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="$BACKUP_BASE/privacy-migration-$DATE"
LOG_FILE="$BACKUP_DIR/backup.log"

# Crear directorio de backup
mkdir -p "$BACKUP_DIR"
exec 1> >(tee -a "$LOG_FILE")
exec 2>&1

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

log "🚀 Iniciando backup integral de migración de privacidad"

# Función para verificar espacio disponible
check_space() {
    local required_gb=$1
    local available_gb=$(df "$BACKUP_BASE" | awk 'NR==2{printf "%.1f", $4/1024/1024}')
    
    if (( $(echo "$available_gb < $required_gb" | bc -l) )); then
        log "❌ Espacio insuficiente. Requerido: ${required_gb}GB, Disponible: ${available_gb}GB"
        exit 1
    fi
    
    log "✅ Espacio suficiente: ${available_gb}GB disponible"
}

# Verificar espacio (estimado 20GB para backup completo)
check_space 20

# Backup Obsidian Vault
backup_obsidian() {
    log "📝 Backing up Obsidian Vault..."
    
    OBSIDIAN_PATHS=(
        "$HOME/ObsidianVault"
        "$HOME/Documents/ObsidianVault" 
        "/Users/$USER/Documents/ObsidianVault"  # macOS
    )
    
    for path in "${OBSIDIAN_PATHS[@]}"; do
        if [ -d "$path" ]; then
            tar -czf "$BACKUP_DIR/obsidian-vault-$(basename "$path").tar.gz" -C "$(dirname "$path")" "$(basename "$path")"
            log "✅ Obsidian Vault backed up: $path"
            return 0
        fi
    done
    
    log "⚠️  Obsidian Vault no encontrado en ubicaciones esperadas"
}

# Backup LibreOffice Documents
backup_libreoffice() {
    log "📄 Backing up LibreOffice documents..."
    
    OFFICE_PATHS=(
        "$HOME/Documents"
        "$HOME/LibreOfficeDocs"
        "/Users/$USER/Documents"
    )
    
    for path in "${OFFICE_PATHS[@]}"; do
        if [ -d "$path" ]; then
            find "$path" -name "*.odt" -o -name "*.ods" -o -name "*.odp" -o -name "*.docx" -o -name "*.xlsx" -o -name "*.pptx" | \
            tar -czf "$BACKUP_DIR/office-documents.tar.gz" -T -
            log "✅ Office documents backed up from: $path"
            break
        fi
    done
}

# Backup Organized Photos
backup_photos() {
    log "📸 Backing up organized photos..."
    
    PHOTO_PATHS=(
        "$HOME/Pictures/Organized-Photos"
        "$HOME/Photos"
        "/Users/$USER/Pictures"
    )
    
    for path in "${PHOTO_PATHS[@]}"; do
        if [ -d "$path" ] && [ "$(find "$path" -name "*.jpg" -o -name "*.png" | wc -l)" -gt 10 ]; then
            tar -czf "$BACKUP_DIR/photos-organized.tar.gz" -C "$(dirname "$path")" "$(basename "$path")"
            log "✅ Photos backed up from: $path"
            break
        fi
    done
}

# Backup Browser Profiles
backup_browsers() {
    log "🌐 Backing up browser profiles..."
    
    # Firefox
    if [ -d "$HOME/.mozilla/firefox" ]; then
        tar -czf "$BACKUP_DIR/firefox-profile.tar.gz" -C "$HOME" .mozilla/firefox
        log "✅ Firefox profile backed up"
    fi
    
    # Chrome/Chromium (si es necesario para transición)
    if [ -d "$HOME/.config/google-chrome" ]; then
        tar --exclude="Cache*" --exclude="GPUCache" -czf "$BACKUP_DIR/chrome-profile.tar.gz" -C "$HOME" .config/google-chrome
        log "✅ Chrome profile backed up (excluding cache)"
    fi
}

# Backup Security Tools Configurations
backup_security() {
    log "🔐 Backing up security configurations..."
    
    # Bitwarden export (debe hacerse manualmente desde la aplicación)
    log "⚠️  Recuerda exportar Bitwarden vault manualmente"
    
    # Aegis backup (Android - debe copiarse manualmente)
    log "⚠️  Recuerda respaldar Aegis tokens desde dispositivo móvil"
    
    # VeraCrypt headers (si existen)
    if command -v veracrypt &> /dev/null; then
        log "✅ VeraCrypt instalado - verificar backups de headers manualmente"
    fi
}

# Backup Email Export (si se tienen archivos locales)
backup_email() {
    log "📧 Backing up email archives..."
    
    EMAIL_PATHS=(
        "$HOME/Thunderbird"
        "$HOME/.thunderbird"
        "$HOME/Gmail-Export"
        "$HOME/Downloads/Gmail-Export"
    )
    
    for path in "${EMAIL_PATHS[@]}"; do
        if [ -d "$path" ]; then
            tar -czf "$BACKUP_DIR/email-$(basename "$path").tar.gz" -C "$(dirname "$path")" "$(basename "$path")"
            log "✅ Email archives backed up: $path"
        fi
    done
}

# Export configuration files
backup_configs() {
    log "⚙️  Backing up configuration files..."
    
    mkdir -p "$BACKUP_DIR/configs"
    
    # SSH keys (si existen)
    if [ -d "$HOME/.ssh" ]; then
        cp -r "$HOME/.ssh" "$BACKUP_DIR/configs/"
        chmod 700 "$BACKUP_DIR/configs/.ssh"
        log "✅ SSH keys backed up"
    fi
    
    # GPG keys (si existen)
    if [ -d "$HOME/.gnupg" ]; then
        cp -r "$HOME/.gnupg" "$BACKUP_DIR/configs/"
        log "✅ GPG keys backed up"
    fi
    
    # ProtonVPN config (si existe)
    if [ -f "$HOME/.config/protonvpn/pvpn-cli.cfg" ]; then
        mkdir -p "$BACKUP_DIR/configs/protonvpn"
        cp "$HOME/.config/protonvpn/pvpn-cli.cfg" "$BACKUP_DIR/configs/protonvpn/"
        log "✅ ProtonVPN config backed up"
    fi
}

# Crear manifest de backup
create_manifest() {
    log "📋 Creating backup manifest..."
    
    cat > "$BACKUP_DIR/MANIFEST.txt" << EOF
PRIVACY MIGRATION BACKUP MANIFEST
================================
Date: $(date)
Hostname: $(hostname)
User: $(whoami)
OS: $(uname -a)

BACKUP CONTENTS:
$(find "$BACKUP_DIR" -name "*.tar.gz" -exec basename {} \; | sort)

VERIFICATION CHECKSUMS:
$(find "$BACKUP_DIR" -name "*.tar.gz" -exec sha256sum {} \;)

RESTORE INSTRUCTIONS:
====================
1. Extract archives: tar -xzf <archive.tar.gz>
2. Restore to appropriate locations
3. Verify permissions and ownership
4. Test functionality of restored data

IMPORTANT NOTES:
===============
- Manual steps required for:
  * Bitwarden vault export/import
  * Aegis authenticator backup
  * Proton services re-authentication
  * Mobile app re-installation and config
EOF

    log "✅ Manifest created"
}

# Cifrar backup completo
encrypt_backup() {
    log "🔒 Encrypting backup archive..."
    
    read -s -p "Enter backup encryption password: " BACKUP_PASSWORD
    echo
    
    # Crear archivo comprimido del backup completo
    tar -czf "$BACKUP_BASE/privacy-backup-$DATE.tar.gz" -C "$BACKUP_BASE" "privacy-migration-$DATE"
    
    # Cifrar con gpg
    echo "$BACKUP_PASSWORD" | gpg --batch --yes --passphrase-fd 0 --symmetric --cipher-algo AES256 --output "$BACKUP_BASE/privacy-backup-$DATE.tar.gz.gpg" "$BACKUP_BASE/privacy-backup-$DATE.tar.gz"
    
    # Eliminar archivo no cifrado
    rm "$BACKUP_BASE/privacy-backup-$DATE.tar.gz"
    
    log "✅ Backup encrypted: privacy-backup-$DATE.tar.gz.gpg"
}

# Ejecución principal
main() {
    backup_obsidian
    backup_libreoffice  
    backup_photos
    backup_browsers
    backup_security
    backup_email
    backup_configs
    create_manifest
    
    log "📊 Backup Statistics:"
    log "   Directory size: $(du -sh "$BACKUP_DIR" | cut -f1)"
    log "   Files created: $(find "$BACKUP_DIR" -type f | wc -l)"
    
    read -p "¿Cifrar backup completo? (y/n): " encrypt_choice
    if [ "$encrypt_choice" = "y" ]; then
        encrypt_backup
        # Limpiar directorio no cifrado
        rm -rf "$BACKUP_DIR"
    fi
    
    log "✅ Backup completo finalizado"
    log "📍 Ubicación: $BACKUP_BASE"
}

# Verificar dependencias
if ! command -v tar &> /dev/null; then
    log "❌ tar no encontrado. Instalar: sudo apt install tar"
    exit 1
fi

if ! command -v gpg &> /dev/null; then
    log "⚠️  gpg no encontrado. Cifrado no disponible"
fi

# Ejecutar backup
main

#!/bin/bash
# privacy_health_check.sh - Verificación semanal de privacidad

# Configuración
LOG_FILE="/var/log/privacy-health.log"
ALERT_EMAIL="[email protected]"  # Cambiar por tu email

log_with_date() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

# Verificar DNS leaks
check_dns_leaks() {
    log_with_date "🔍 Verificando DNS leaks..."
    
    # Test básico de DNS
    DNS_RESULT=$(dig +short TXT whoami.cloudflare @1.1.1.1 | tr -d '"')
    
    if echo "$DNS_RESULT" | grep -q "cloudflare"; then
        log_with_date "✅ DNS test passed: $DNS_RESULT"
    else
        log_with_date "⚠️  DNS test anomaly: $DNS_RESULT"
    fi
}

# Verificar VPN status
check_vpn_status() {
    log_with_date "🛡️  Verificando estado VPN..."
    
    # Para ProtonVPN
    if command -v protonvpn-cli &> /dev/null; then
        VPN_STATUS=$(protonvpn-cli status 2>/dev/null)
        if echo "$VPN_STATUS" | grep -q "Connected"; then
            log_with_date "✅ ProtonVPN conectado"
        else
            log_with_date "⚠️  ProtonVPN desconectado"
        fi
    fi
}

# Verificar actualizaciones de seguridad
check_security_updates() {
    log_with_date "📦 Verificando actualizaciones de seguridad..."
    
    if command -v apt &> /dev/null; then
        # Ubuntu/Debian
        apt list --upgradable 2>/dev/null | grep -i security | wc -l > /tmp/security_updates
        SECURITY_COUNT=$(cat /tmp/security_updates)
        
        if [ "$SECURITY_COUNT" -gt 0 ]; then
            log_with_date "⚠️  $SECURITY_COUNT actualizaciones de seguridad disponibles"
        else
            log_with_date "✅ Sin actualizaciones de seguridad pendientes"
        fi
    fi
}

# Verificar integridad de backups
check_backup_integrity() {
    log_with_date "💾 Verificando integridad de backups..."
    
    BACKUP_DIR="/media/external-backup"
    if [ -d "$BACKUP_DIR" ]; then
        LAST_BACKUP=$(find "$BACKUP_DIR" -name "privacy-backup-*.gpg" -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -d' ' -f2-)
        
        if [ -n "$LAST_BACKUP" ]; then
            BACKUP_AGE=$(( ($(date +%s) - $(stat -c %Y "$LAST_BACKUP")) / 86400 ))
            
            if [ "$BACKUP_AGE" -le 7 ]; then
                log_with_date "✅ Backup reciente encontrado: $(basename "$LAST_BACKUP") ($BACKUP_AGE días)"
            else
                log_with_date "⚠️  Backup antiguo: $BACKUP_AGE días"
            fi
        else
            log_with_date "❌ No se encontraron backups cifrados"
        fi
    else
        log_with_date "⚠️  Directorio de backup no encontrado: $BACKUP_DIR"
    fi
}

# Verificar servicios críticos
check_critical_services() {
    log_with_date "🔄 Verificando servicios críticos..."
    
    # Proton Bridge
    if pgrep -f "protonmail-bridge" > /dev/null; then
        log_with_date "✅ Proton Bridge ejecutándose"
    else
        log_with_date "⚠️  Proton Bridge no activo"
    fi
    
    # Firefox con perfil privacidad
    if pgrep firefox > /dev/null; then
        log_with_date "✅ Firefox activo"
    fi
}

# Verificar configuraciones de privacidad
check_privacy_settings() {
    log_with_date "🔐 Verificando configuraciones de privacidad..."
    
    # Verificar que servicios Google estén deshabilitados
    if systemctl --user is-active google-chrome-stable &>/dev/null; then
        log_with_date "⚠️  Chrome aún activo - considerar deshabilitar"
    fi
    
    # Verificar configuración Firefox (simplificado)
    FIREFOX_PROFILE=$(find ~/.mozilla/firefox -name "prefs.js" | head -1)
    if [ -f "$FIREFOX_PROFILE" ]; then
        if grep -q "privacy.trackingprotection.enabled.*true" "$FIREFOX_PROFILE"; then
            log_with_date "✅ Firefox tracking protection habilitado"
        else
            log_with_date "⚠️  Revisar configuración tracking protection Firefox"
        fi
    fi
}

# Generar reporte de salud
generate_health_report() {
    log_with_date "📊 Generando reporte de salud de privacidad..."
    
    REPORT_FILE="/tmp/privacy-health-report-$(date +%Y%m%d).txt"
    
    cat > "$REPORT_FILE" << EOF
REPORTE DE SALUD DE PRIVACIDAD
=============================
Fecha: $(date)
Hostname: $(hostname)

RESUMEN DE VERIFICACIONES:
$(tail -20 "$LOG_FILE")

RECOMENDACIONES:
$(grep "⚠️\|❌" "$LOG_FILE" | tail -10)

PRÓXIMA VERIFICACIÓN: $(date -d '+7 days' '+%Y-%m-%d')
EOF

    log_with_date "📋 Reporte generado: $REPORT_FILE"
    
    # Enviar por email si hay alertas
    ALERT_COUNT=$(grep -c "⚠️\|❌" "$LOG_FILE" | tail -1)
    if [ "$ALERT_COUNT" -gt 0 ]; then
        # Aquí iría la lógica para enviar email de alerta
        log_with_date "📧 $ALERT_COUNT alertas detectadas - revisar configuración"
    fi
}

# Ejecutar todas las verificaciones
main() {
    log_with_date "🚀 Iniciando verificación semanal de privacidad"
    
    check_dns_leaks
    check_vpn_status  
    check_security_updates
    check_backup_integrity
    check_critical_services
    check_privacy_settings
    generate_health_report
    
    log_with_date "✅ Verificación completada"
}

# Configurar como cronjob semanal
setup_cron() {
    echo "Configurando verificación semanal..."
    echo "0 9 * * 1 /path/to/privacy_health_check.sh" | crontab -
    echo "✅ Cronjob configurado para lunes a las 9:00 AM"
}

# Ejecutar verificación
main

# Preguntar si configurar como cron job
read -p "¿Configurar verificación automática semanal? (y/n): " setup_cron_choice
[ "$setup_cron_choice" = "y" ] && setup_cron

# Instalación con Docker
docker run -d \
  --name nextcloud \
  -p 8080:80 \
  -v nextcloud_data:/var/www/html \
  nextcloud:latest

# Configuración inicial en http://localhost:8080

# Para usuarios muy avanzados - requiere servidor dedicado
git clone https://github.com/mailcow/mailcow-dockerized
cd mailcow-dockerized
./generate_config.sh
docker-compose up -d

firefox -ProfileManager
# Crear perfil "Banking" con menos restricciones
# Usar perfil "Privacy" para navegación general

#!/bin/bash
# monthly_maintenance.sh - Mantenimiento mensual del ecosistema de privacidad

MAINTENANCE_LOG="/var/log/privacy-maintenance.log"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$MAINTENANCE_LOG"
}

# Actualizar todas las aplicaciones de privacidad
update_privacy_tools() {
    log "🔄 Actualizando herramientas de privacidad..."
    
    # Actualizar sistema base
    if command -v apt &> /dev/null; then
        sudo apt update && sudo apt upgrade -y
    elif command -v yum &> /dev/null; then
        sudo yum update -y
    fi
    
    # Actualizar Firefox si está instalado manualmente
    if [ -d "/opt/firefox" ]; then
        log "🦊 Verificando actualización manual de Firefox..."
        CURRENT_VERSION=$(firefox --version 2>/dev/null | awk '{print $3}')
        log "   Versión actual: $CURRENT_VERSION"
    fi
    
    # Actualizar Obsidian si está instalado como AppImage
    if [ -f "$HOME/Applications/Obsidian.AppImage" ]; then
        log "📝 Obsidian AppImage detectado - verificar actualizaciones manualmente"
    fi
    
    log "✅ Actualizaciones del sistema completadas"
}

# Rotar y limpiar logs
clean_logs() {
    log "🧹 Limpiando logs antiguos..."
    
    # Rotar logs de privacidad
    find /var/log -name "*privacy*" -name "*.log" -mtime +30 -delete 2>/dev/null
    find "$HOME/.local/share" -name "*.log" -mtime +30 -delete 2>/dev/null
    
    # Limpiar cache de navegadores
    if [ -d "$HOME/.cache/mozilla" ]; then
        du -sh "$HOME/.cache/mozilla" | log
        rm -rf "$HOME/.cache/mozilla/firefox/*/cache*" 2>/dev/null
    fi
    
    log "✅ Limpieza de logs completada"
}

# Verificar integridad de backups
verify_backups() {
    log "🔍 Verificando integridad de backups..."
    
    BACKUP_DIR="/media/external-backup"
    if [ -d "$BACKUP_DIR" ]; then
        BACKUP_COUNT=$(find "$BACKUP_DIR" -name "*.tar.gz.gpg" | wc -l)
        LATEST_BACKUP=$(find "$BACKUP_DIR" -name "*.tar.gz.gpg" -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -d' ' -f2-)
        
        if [ -n "$LATEST_BACKUP" ]; then
            BACKUP_SIZE=$(du -h "$LATEST_BACKUP" | cut -f1)
            BACKUP_DATE=$(date -r "$LATEST_BACKUP" '+%Y-%m-%d')
            log "✅ Último backup: $BACKUP_DATE, Tamaño: $BACKUP_SIZE"
        else
            log "⚠️  No se encontraron backups recientes"
        fi
        
        log "📊 Total de backups: $BACKUP_COUNT"
    else
        log "❌ Directorio de backup no encontrado"
    fi
}

# Verificar configuraciones de privacidad
audit_privacy_settings() {
    log "🔐 Auditando configuraciones de privacidad..."
    
    # Verificar configuración Firefox
    FIREFOX_PROFILES=$(find ~/.mozilla/firefox -name "prefs.js" 2>/dev/null)
    for profile in $FIREFOX_PROFILES; do
        if grep -q "privacy.trackingprotection.enabled.*true" "$profile"; then
            log "✅ Tracking protection activo en $(basename $(dirname "$profile"))"
        else
            log "⚠️  Revisar tracking protection en $(basename $(dirname "$profile"))"
        fi
    done
    
    # Verificar servicios en ejecución
    if pgrep -f "protonmail-bridge" > /dev/null; then
        log "✅ Proton Bridge ejecutándose"
    else
        log "⚠️  Proton Bridge no detectado"
    fi
    
    # Verificar VPN
    if command -v protonvpn-cli &> /dev/null; then
        VPN_STATUS=$(protonvpn-cli status 2>/dev/null)
        if echo "$VPN_STATUS" | grep -q "Connected"; then
            SERVER=$(echo "$VPN_STATUS" | grep "Server" | awk '{print $2}')
            log "✅ VPN conectado a: $SERVER"
        else
            log "ℹ️  VPN desconectado (normal si no se usa constantemente)"
        fi
    fi
}

# Generar reporte mensual
generate_monthly_report() {
    log "📊 Generando reporte mensual..."
    
    REPORT_FILE="/tmp/monthly-privacy-report-$(date +%Y%m).txt"
    
    cat > "$REPORT_FILE" << EOF
REPORTE MENSUAL DE PRIVACIDAD DIGITAL
====================================
Fecha: $(date)
Usuario: $(whoami)
Sistema: $(uname -a)

ESTADO DE HERRAMIENTAS:
$(grep -E "✅|⚠️|❌" "$MAINTENANCE_LOG" | tail -20)

ESTADÍSTICAS DE USO:
- Backups realizados este mes: $(find /media/external-backup -name "*.gpg" -newermt "$(date -d '30 days ago')" | wc -l 2>/dev/null || echo "N/A")
- Espacio utilizado Obsidian: $(du -sh ~/ObsidianVault 2>/dev/null | cut -f1 || echo "N/A")
- Logs de privacidad generados: $(wc -l < "$MAINTENANCE_LOG")

RECOMENDACIONES PARA EL PRÓXIMO MES:
- Revisar elementos marcados con ⚠️  
- Verificar actualizaciones de aplicaciones instaladas manualmente
- Considerar expandir almacenamiento si los backups crecen significativamente
- Evaluar nuevas herramientas de privacidad disponibles

PRÓXIMO MANTENIMIENTO: $(date -d '+1 month' '+%Y-%m-%d')
EOF

    log "📋 Reporte generado: $REPORT_FILE"
    
    # Mostrar resumen en pantalla
    echo ""
    echo "=== RESUMEN DEL MANTENIMIENTO MENSUAL ==="
    grep -E "✅|⚠️|❌" "$MAINTENANCE_LOG" | tail -10
    echo ""
    echo "📄 Reporte completo disponible en: $REPORT_FILE"
}

# Función principal
main() {
    log "🚀 Iniciando mantenimiento mensual de privacidad"
    
    update_privacy_tools
    clean_logs
    verify_backups
    audit_privacy_settings
    generate_monthly_report
    
    log "✅ Mantenimiento mensual completado"
}

# Verificar permisos y ejecutar
if [[ $EUID -eq 0 ]]; then
   log "❌ No ejecutar como root por seguridad"
   exit 1
fi

main

# Configurar como cronjob mensual
setup_monthly_cron() {
    echo "Configurando mantenimiento automático mensual..."
    (crontab -l 2>/dev/null; echo "0 10 1 * * /path/to/monthly_maintenance.sh") | crontab -
    echo "✅ Cronjob configurado para el primer día de cada mes a las 10:00 AM"
}

read -p "¿Configurar mantenimiento automático mensual? (y/n): " setup_cron_choice
[ "$setup_cron_choice" = "y" ] && setup_monthly_cron