#!/bin/bash

#-------------------------------------COLORES PARA MENSAJES------------------------------------------------------------
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
MAGENTA='\033[0;35m'
NC='\033[0m' # No Color
BOLD='\033[1m'

#-------------------------------------FUNCIONES DE MENSAJES------------------------------------------------------------
print_header() {
    echo ""
    echo -e "${RED}╔═══════════════════════════════════════════════════════════════╗${NC}"
    echo -e "${RED}║                                                               ║${NC}"
    echo -e "${RED}║  ${BOLD}${MAGENTA}     ⚠️  ELIMINAR INSTALACIÓN DOCKER - APIDIAN${NC}${RED}            ║${NC}"
    echo -e "${RED}║  ${YELLOW}     Este script eliminará COMPLETAMENTE la instalación${NC}${RED}    ║${NC}"
    echo -e "${RED}║                                                               ║${NC}"
    echo -e "${RED}╚═══════════════════════════════════════════════════════════════╝${NC}"
    echo ""
}

print_success() {
    echo -e "${GREEN}✓ $1${NC}"
}

print_error() {
    echo -e "${RED}✗ $1${NC}"
}

print_warning() {
    echo -e "${YELLOW}⚠ $1${NC}"
}

print_info() {
    echo -e "${BLUE}ℹ $1${NC}"
}

print_step() {
    echo ""
    echo -e "${CYAN}${BOLD}▶ $1${NC}"
    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
}

print_danger() {
    echo -e "${RED}${BOLD}⚠️  $1${NC}"
}

# Mostrar header
print_header

#-------------------------------------VERIFICAR ROOT------------------------------------------------------------
if [ "$EUID" -ne 0 ]; then
    print_error "Este script debe ejecutarse como root"
    echo -e "${YELLOW}Usa: sudo bash $0${NC}"
    exit 1
fi

print_success "Ejecutando como root"

# Información del sistema
UBUNTU_VERSION=$(lsb_release -rs)
UBUNTU_MAJOR=$(echo "$UBUNTU_VERSION" | cut -d. -f1)

if [[ "$UBUNTU_MAJOR" -lt 20 ]]; then
    print_error "Script no compatible con Ubuntu < 20.04"
    exit 1
fi

print_info "Sistema: Ubuntu $UBUNTU_VERSION"

#-------------------------------------VERIFICAR DOCKER-----------------------------------------------------------------
if ! command -v docker &> /dev/null; then
    print_warning "Docker no está instalado en este sistema"
    echo ""
    read -p "$(echo -e ${YELLOW}¿Deseas continuar de todas formas para limpiar archivos? [s/n]: ${NC})" continue_anyway
    if [ "$continue_anyway" != "s" ]; then
        print_info "Operación cancelada"
        exit 0
    fi
    DOCKER_INSTALLED=false
else
    DOCKER_INSTALLED=true
    DOCKER_VERSION=$(docker --version 2>/dev/null | grep -oP '\d+\.\d+\.\d+' | head -n1)
    print_info "Docker detectado: versión $DOCKER_VERSION"
fi

#-------------------------------------DETECTAR INSTALACIONES-----------------------------------------------------------
print_step "Detectando instalaciones existentes"

CURRENT_DIR=$(pwd)
INSTALLATIONS_FOUND=false

# Buscar docker-compose.yml en directorio actual
if [ -f "$CURRENT_DIR/docker-compose.yml" ]; then
    print_warning "Instalación encontrada en: ${BOLD}$CURRENT_DIR${NC}"
    INSTALLATIONS_FOUND=true
    INSTALL_PATH="$CURRENT_DIR"
fi

# Buscar en /root si no estamos ahí
if [ "$CURRENT_DIR" != "/root" ] && [ -f "/root/docker-compose.yml" ]; then
    print_warning "Instalación encontrada en: ${BOLD}/root${NC}"
    INSTALLATIONS_FOUND=true
    if [ -z "$INSTALL_PATH" ]; then
        INSTALL_PATH="/root"
    fi
fi

if [ "$INSTALLATIONS_FOUND" = false ]; then
    print_info "No se encontraron instalaciones Docker de APIDIAN"
    echo ""
    read -p "$(echo -e ${YELLOW}¿Deseas hacer una limpieza completa de Docker de todas formas? [s/n]: ${NC})" clean_anyway
    if [ "$clean_anyway" != "s" ]; then
        print_info "Operación cancelada"
        exit 0
    fi
fi

#-------------------------------------MOSTRAR INFORMACIÓN--------------------------------------------------------------
echo ""
echo -e "${RED}${BOLD}╔═══════════════════════════════════════════════════════════════╗${NC}"
echo -e "${RED}${BOLD}║                  ⚠️  ADVERTENCIA CRÍTICA ⚠️                   ║${NC}"
echo -e "${RED}${BOLD}╚═══════════════════════════════════════════════════════════════╝${NC}"
echo ""
echo -e "${YELLOW}Este script realizará las siguientes acciones IRREVERSIBLES:${NC}"
echo ""
echo -e "${RED}1. Detener y eliminar TODOS los contenedores Docker${NC}"
echo -e "${RED}2. Eliminar TODOS los volúmenes Docker (incluyendo bases de datos)${NC}"
echo -e "${RED}3. Eliminar TODAS las imágenes Docker${NC}"
echo -e "${RED}4. Eliminar redes Docker personalizadas${NC}"
echo -e "${RED}5. Eliminar directorio de aplicación (apidian/)${NC}"
echo -e "${RED}6. Eliminar archivos de configuración (setup/, .env, docker-compose.yml)${NC}"
echo -e "${RED}7. Eliminar certificados SSL si existen${NC}"
echo ""
echo -e "${YELLOW}${BOLD}⚠️  DATOS QUE SE PERDERÁN:${NC}"
echo -e "${RED}   • Base de datos completa (MySQL/MariaDB)${NC}"
echo -e "${RED}   • Archivos subidos por usuarios${NC}"
echo -e "${RED}   • Logs de la aplicación${NC}"
echo -e "${RED}   • Configuraciones personalizadas${NC}"
echo -e "${RED}   • Certificados SSL${NC}"
echo ""

# Mostrar contenedores actuales si Docker está instalado
if [ "$DOCKER_INSTALLED" = true ]; then
    RUNNING_CONTAINERS=$(docker ps -q | wc -l)
    ALL_CONTAINERS=$(docker ps -aq | wc -l)
    VOLUMES=$(docker volume ls -q | wc -l)
    IMAGES=$(docker images -q | wc -l)

    echo -e "${CYAN}Estado actual de Docker:${NC}"
    echo -e "  • Contenedores corriendo: ${BOLD}$RUNNING_CONTAINERS${NC}"
    echo -e "  • Contenedores totales: ${BOLD}$ALL_CONTAINERS${NC}"
    echo -e "  • Volúmenes: ${BOLD}$VOLUMES${NC}"
    echo -e "  • Imágenes: ${BOLD}$IMAGES${NC}"
    echo ""

    if [ $RUNNING_CONTAINERS -gt 0 ]; then
        echo -e "${YELLOW}Contenedores en ejecución:${NC}"
        docker ps --format "  • {{.Names}} ({{.Image}}) - {{.Status}}"
        echo ""
    fi
fi

#-------------------------------------CONFIRMACIÓN 1-------------------------------------------------------------------
echo -e "${RED}${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
read -p "$(echo -e ${RED}${BOLD}¿Estás seguro que deseas ELIMINAR TODO? [si/no]: ${NC})" confirm1

if [ "$confirm1" != "si" ]; then
    print_success "Operación cancelada por el usuario"
    echo -e "${GREEN}No se realizaron cambios${NC}"
    exit 0
fi

#-------------------------------------CONFIRMACIÓN 2-------------------------------------------------------------------
echo ""
echo -e "${RED}${BOLD}⚠️  ÚLTIMA ADVERTENCIA ⚠️${NC}"
echo ""
echo -e "${YELLOW}Esta acción NO se puede deshacer.${NC}"
echo -e "${YELLOW}Todos los datos se perderán permanentemente.${NC}"
echo ""
read -p "$(echo -e ${RED}${BOLD}Escribe 'ELIMINAR TODO' para confirmar: ${NC})" confirm2

if [ "$confirm2" != "ELIMINAR TODO" ]; then
    print_success "Operación cancelada por el usuario"
    echo -e "${GREEN}No se realizaron cambios${NC}"
    exit 0
fi

#-------------------------------------CONFIRMACIÓN 3 (ÚLTIMA)---------------------------------------------------------
echo ""
echo -e "${RED}${BOLD}╔═══════════════════════════════════════════════════════════════╗${NC}"
echo -e "${RED}${BOLD}║              CONFIRMACIÓN FINAL - NO HAY VUELTA ATRÁS         ║${NC}"
echo -e "${RED}${BOLD}╚═══════════════════════════════════════════════════════════════╝${NC}"
echo ""
read -p "$(echo -e ${RED}${BOLD}¿Proceder con la eliminación? [SI/NO]: ${NC})" confirm3

if [ "$confirm3" != "SI" ]; then
    print_success "Operación cancelada por el usuario"
    echo -e "${GREEN}No se realizaron cambios${NC}"
    exit 0
fi

echo ""
print_danger "Iniciando proceso de eliminación..."
sleep 2

#-------------------------------------CREAR BACKUP DE CREDENCIALES (OPCIONAL)------------------------------------------
if [ -f "$INSTALL_PATH/setup/private.txt" ]; then
    echo ""
    read -p "$(echo -e ${YELLOW}¿Deseas hacer backup de las credenciales antes de eliminar? [s/n]: ${NC})" backup_creds
    if [ "$backup_creds" = "s" ]; then
        BACKUP_FILE="/tmp/apidian_credentials_backup_$(date +%Y%m%d_%H%M%S).txt"
        cp "$INSTALL_PATH/setup/private.txt" "$BACKUP_FILE" 2>/dev/null
        print_success "Backup guardado en: $BACKUP_FILE"
    fi
fi

#-------------------------------------DETENER CONTENEDORES-------------------------------------------------------------
if [ "$DOCKER_INSTALLED" = true ]; then
    print_step "Deteniendo contenedores Docker"

    RUNNING=$(docker ps -q | wc -l)
    if [ $RUNNING -gt 0 ]; then
        print_info "Deteniendo $RUNNING contenedor(es) en ejecución..."
        docker stop $(docker ps -aq) 2>/dev/null
        print_success "Contenedores detenidos"
    else
        print_info "No hay contenedores en ejecución"
    fi
fi

#-------------------------------------ELIMINAR CONTENEDORES------------------------------------------------------------
if [ "$DOCKER_INSTALLED" = true ]; then
    print_step "Eliminando contenedores Docker"

    CONTAINERS=$(docker ps -aq | wc -l)
    if [ $CONTAINERS -gt 0 ]; then
        print_info "Eliminando $CONTAINERS contenedor(es)..."
        docker rm -f $(docker ps -aq) 2>/dev/null
        print_success "Contenedores eliminados"
    else
        print_info "No hay contenedores para eliminar"
    fi
fi

#-------------------------------------ELIMINAR VOLUMENES--------------------------------------------------------------
if [ "$DOCKER_INSTALLED" = true ]; then
    print_step "Eliminando volúmenes Docker"

    VOLUMES=$(docker volume ls -q | wc -l)
    if [ $VOLUMES -gt 0 ]; then
        print_warning "Eliminando $VOLUMES volumen(es) (incluyendo datos de bases de datos)..."
        docker volume rm $(docker volume ls -q) 2>/dev/null

        # Forzar eliminación de volúmenes huérfanos
        print_info "Limpiando volúmenes huérfanos..."
        docker volume prune -f 2>/dev/null
        print_success "Volúmenes eliminados"
    else
        print_info "No hay volúmenes para eliminar"
    fi
fi

#-------------------------------------ELIMINAR REDES-------------------------------------------------------------------
if [ "$DOCKER_INSTALLED" = true ]; then
    print_step "Eliminando redes Docker personalizadas"

    # Eliminar red proxynet si existe
    if docker network ls | grep -q "proxynet"; then
        print_info "Eliminando red 'proxynet'..."
        docker network rm proxynet 2>/dev/null
        print_success "Red 'proxynet' eliminada"
    fi

    # Eliminar red webnet si existe
    if docker network ls | grep -q "webnet"; then
        print_info "Eliminando red 'webnet'..."
        docker network rm webnet 2>/dev/null
        print_success "Red 'webnet' eliminada"
    fi

    # Limpiar redes no utilizadas
    print_info "Limpiando redes no utilizadas..."
    docker network prune -f 2>/dev/null
    print_success "Redes personalizadas eliminadas"
fi

#-------------------------------------ELIMINAR IMAGENES----------------------------------------------------------------
if [ "$DOCKER_INSTALLED" = true ]; then
    print_step "Eliminando imágenes Docker"

    IMAGES=$(docker images -q | wc -l)
    if [ $IMAGES -gt 0 ]; then
        print_warning "Eliminando $IMAGES imagen(es)..."
        docker rmi -f $(docker images -aq) 2>/dev/null

        # Limpiar imágenes huérfanas y sin etiquetar
        print_info "Limpiando imágenes huérfanas..."
        docker image prune -af 2>/dev/null
        print_success "Imágenes eliminadas"
    else
        print_info "No hay imágenes para eliminar"
    fi
fi

#-------------------------------------LIMPIAR CACHE DE DOCKER----------------------------------------------------------
if [ "$DOCKER_INSTALLED" = true ]; then
    print_step "Limpiando cache del sistema Docker"

    print_info "Eliminando cache de construcción..."
    docker builder prune -af 2>/dev/null

    print_info "Limpieza completa del sistema Docker..."
    docker system prune -af --volumes 2>/dev/null

    print_success "Cache de Docker limpiado"
fi

#-------------------------------------ELIMINAR DIRECTORIOS DE APLICACION----------------------------------------------
print_step "Eliminando directorios de la aplicación"

# Determinar ruta de instalación
if [ -n "$INSTALL_PATH" ]; then
    cd "$INSTALL_PATH"

    # Eliminar directorio de aplicación
    if [ -d "apidian" ]; then
        print_info "Eliminando directorio: apidian/"
        rm -rf apidian
        print_success "Directorio 'apidian' eliminado"
    fi

    # Eliminar directorio setup
    if [ -d "setup" ]; then
        print_info "Eliminando directorio: setup/"
        rm -rf setup
        print_success "Directorio 'setup' eliminado"
    fi

    # Eliminar docker-compose.yml
    if [ -f "docker-compose.yml" ]; then
        print_info "Eliminando archivo: docker-compose.yml"
        rm -f docker-compose.yml
        print_success "Archivo 'docker-compose.yml' eliminado"
    fi

    # Eliminar .env principal
    if [ -f ".env" ]; then
        print_info "Eliminando archivo: .env"
        rm -f .env
        print_success "Archivo '.env' eliminado"
    fi
fi

#-------------------------------------ELIMINAR CERTIFICADOS SSL--------------------------------------------------------
print_step "Verificando certificados SSL"

if [ -d "/etc/letsencrypt/live" ]; then
    CERT_COUNT=$(ls -1 /etc/letsencrypt/live | wc -l)
    if [ $CERT_COUNT -gt 0 ]; then
        echo ""
        print_warning "Se encontraron $CERT_COUNT certificado(s) SSL"
        ls -1 /etc/letsencrypt/live
        echo ""
        read -p "$(echo -e ${YELLOW}¿Deseas eliminar los certificados SSL? [s/n]: ${NC})" delete_certs

        if [ "$delete_certs" = "s" ]; then
            print_info "Eliminando certificados SSL..."
            rm -rf /etc/letsencrypt/live/*
            rm -rf /etc/letsencrypt/archive/*
            rm -rf /etc/letsencrypt/renewal/*
            print_success "Certificados SSL eliminados"
        else
            print_info "Certificados SSL conservados"
        fi
    else
        print_info "No se encontraron certificados SSL"
    fi
else
    print_info "No se encontró directorio de certificados SSL"
fi

#-------------------------------------VERIFICACION FINAL---------------------------------------------------------------
print_step "Verificación final"

if [ "$DOCKER_INSTALLED" = true ]; then
    REMAINING_CONTAINERS=$(docker ps -aq | wc -l)
    REMAINING_VOLUMES=$(docker volume ls -q | wc -l)
    REMAINING_IMAGES=$(docker images -q | wc -l)
    REMAINING_NETWORKS=$(docker network ls | grep -v "bridge\|host\|none" | wc -l)
    REMAINING_NETWORKS=$((REMAINING_NETWORKS - 1)) # Restar línea de encabezado

    echo -e "${CYAN}Estado de Docker después de la limpieza:${NC}"
    echo -e "  • Contenedores: ${BOLD}$REMAINING_CONTAINERS${NC}"
    echo -e "  • Volúmenes: ${BOLD}$REMAINING_VOLUMES${NC}"
    echo -e "  • Imágenes: ${BOLD}$REMAINING_IMAGES${NC}"
    echo -e "  • Redes personalizadas: ${BOLD}$REMAINING_NETWORKS${NC}"
    echo ""

    if [ $REMAINING_CONTAINERS -eq 0 ] && [ $REMAINING_VOLUMES -eq 0 ] && [ $REMAINING_IMAGES -eq 0 ]; then
        print_success "Docker completamente limpio"
    else
        print_warning "Algunos elementos no pudieron ser eliminados"
        if [ $REMAINING_CONTAINERS -gt 0 ]; then
            echo -e "${YELLOW}Contenedores restantes:${NC}"
            docker ps -a
        fi
        if [ $REMAINING_IMAGES -gt 0 ]; then
            echo -e "${YELLOW}Imágenes restantes:${NC}"
            docker images
        fi
    fi
fi

# Verificar directorios
echo ""
echo -e "${CYAN}Verificación de directorios:${NC}"
if [ ! -d "$INSTALL_PATH/apidian" ]; then
    print_success "Directorio 'apidian' eliminado"
else
    print_warning "Directorio 'apidian' aún existe"
fi

if [ ! -d "$INSTALL_PATH/setup" ]; then
    print_success "Directorio 'setup' eliminado"
else
    print_warning "Directorio 'setup' aún existe"
fi

if [ ! -f "$INSTALL_PATH/docker-compose.yml" ]; then
    print_success "Archivo 'docker-compose.yml' eliminado"
else
    print_warning "Archivo 'docker-compose.yml' aún existe"
fi

#-------------------------------------RESUMEN FINAL--------------------------------------------------------------------
echo ""
echo -e "${GREEN}${BOLD}╔═══════════════════════════════════════════════════════════════╗${NC}"
echo -e "${GREEN}${BOLD}║                                                               ║${NC}"
echo -e "${GREEN}${BOLD}║  ✓  ELIMINACIÓN COMPLETADA EXITOSAMENTE                       ║${NC}"
echo -e "${GREEN}${BOLD}║                                                               ║${NC}"
echo -e "${GREEN}${BOLD}╚═══════════════════════════════════════════════════════════════╝${NC}"
echo ""
echo -e "${CYAN}${BOLD}📋 RESUMEN DE LA OPERACIÓN:${NC}"
echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}✓ Contenedores Docker eliminados${NC}"
echo -e "${GREEN}✓ Volúmenes Docker eliminados${NC}"
echo -e "${GREEN}✓ Imágenes Docker eliminadas${NC}"
echo -e "${GREEN}✓ Redes personalizadas eliminadas${NC}"
echo -e "${GREEN}✓ Directorios de aplicación eliminados${NC}"
echo -e "${GREEN}✓ Archivos de configuración eliminados${NC}"
echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${BLUE}El VPS está ahora completamente limpio y listo para una nueva instalación.${NC}"
echo ""
echo -e "${YELLOW}Comandos útiles para verificar:${NC}"
echo -e "  ${CYAN}• docker ps -a${NC}           (Ver contenedores)"
echo -e "  ${CYAN}• docker images${NC}          (Ver imágenes)"
echo -e "  ${CYAN}• docker volume ls${NC}       (Ver volúmenes)"
echo -e "  ${CYAN}• docker network ls${NC}      (Ver redes)"
echo -e "  ${CYAN}• df -h${NC}                  (Ver espacio en disco liberado)"
echo ""

# Mostrar espacio liberado
DISK_INFO=$(df -h / | tail -1 | awk '{print "Disponible: "$4" de "$2" ("$5" usado)"}')
echo -e "${GREEN}💾 Espacio en disco: $DISK_INFO${NC}"
echo ""

print_success "Proceso completado"
echo ""