#!/bin/bash

# 🧹 MYP Bereinigungs-Skript (Linux/macOS)
# Vollständige Bereinigung aller Docker-Ressourcen

set -e

# Parameter
FORCE_FLAG=""
KEEP_VOLUMES_FLAG=""
VERBOSE_FLAG=""

# Farbkodierte Ausgabe
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
MAGENTA='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

print_colored() {
    local color="$1"
    local message="$2"
    echo -e "${color}${message}${NC}"
}

print_step() {
    print_colored "$CYAN" "🔧 $1"
}

print_success() {
    print_colored "$GREEN" "✅ $1"
}

print_warning() {
    print_colored "$YELLOW" "⚠️ $1"
}

print_error() {
    print_colored "$RED" "❌ $1"
}

# Hilfefunktion
show_help() {
    echo "Verwendung: $0 [OPTIONEN]"
    echo ""
    echo "OPTIONEN:"
    echo "  --force         Keine Bestätigung anfordern"
    echo "  --keep-volumes  Volumes (Datenbanken) beibehalten"
    echo "  --verbose       Ausführliche Ausgabe"
    echo "  --help          Diese Hilfe anzeigen"
    echo ""
    echo "Beispiele:"
    echo "  $0 --force"
    echo "  $0 --keep-volumes --verbose"
}

# Parameter verarbeiten
while [[ $# -gt 0 ]]; do
    case $1 in
        --force)
            FORCE_FLAG="--force"
            ;;
        --keep-volumes)
            KEEP_VOLUMES_FLAG="--keep-volumes"
            ;;
        --verbose)
            VERBOSE_FLAG="--verbose"
            ;;
        --help)
            show_help
            exit 0
            ;;
        *)
            print_error "Unbekannter Parameter: $1"
            show_help
            exit 1
            ;;
    esac
    shift
done

# Header
print_colored "$MAGENTA" "╔═══════════════════════════════════════════════════════╗"
print_colored "$MAGENTA" "║              🧹 MYP Bereinigung                        ║"
print_colored "$MAGENTA" "║           Docker-Ressourcen aufräumen                 ║"
print_colored "$MAGENTA" "╚═══════════════════════════════════════════════════════╝"

# Bestätigung anfordern (außer bei --force)
if [[ -z "$FORCE_FLAG" ]]; then
    print_warning "WARNUNG: Diese Aktion wird alle MYP-Container, Images und Netzwerke entfernen!"
    if [[ -z "$KEEP_VOLUMES_FLAG" ]]; then
        print_warning "Auch alle Volumes (einschließlich Datenbanken) werden gelöscht!"
    fi
    
    read -p "Möchten Sie fortfahren? (j/N): " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Jj]$ ]]; then
        echo "Bereinigung abgebrochen."
        exit 0
    fi
fi

# Docker Verfügbarkeit prüfen
if ! docker info &> /dev/null; then
    print_error "Docker ist nicht verfügbar oder läuft nicht."
    exit 1
fi

# Aktuelle Docker Compose Services stoppen
print_step "Stoppe Docker Compose Services..."
{
    COMPOSE_FILES=("docker-compose.yml")
    if [[ -f "docker-compose.dev.yml" ]]; then
        COMPOSE_FILES+=("docker-compose.dev.yml")
    fi
    if [[ -f "docker-compose.override.yml" ]]; then
        COMPOSE_FILES+=("docker-compose.override.yml")
    fi
    
    COMPOSE_ARGS=()
    for file in "${COMPOSE_FILES[@]}"; do
        COMPOSE_ARGS+=("-f" "$file")
    done
    
    docker-compose "${COMPOSE_ARGS[@]}" down --remove-orphans &> /dev/null
    print_success "Services gestoppt"
} || {
    print_warning "Fehler beim Stoppen der Services"
}

# MYP-spezifische Container entfernen
print_step "Entferne MYP-Container..."
{
    MYP_CONTAINERS=$(docker ps -a --filter "name=myp-" --format "{{.Names}}" 2>/dev/null || true)
    if [[ -n "$MYP_CONTAINERS" ]]; then
        echo "$MYP_CONTAINERS" | xargs docker rm -f &> /dev/null
        print_success "MYP-Container entfernt: $MYP_CONTAINERS"
    else
        echo "Keine MYP-Container gefunden"
    fi
} || {
    print_warning "Fehler beim Entfernen der Container"
}

# MYP-spezifische Images entfernen
print_step "Entferne MYP-Images..."
{
    MYP_IMAGES=$(docker images --filter "reference=*myp*" --format "{{.Repository}}:{{.Tag}}" 2>/dev/null || true)
    if [[ -n "$MYP_IMAGES" ]]; then
        echo "$MYP_IMAGES" | xargs docker rmi -f &> /dev/null
        print_success "MYP-Images entfernt: $MYP_IMAGES"
    else
        echo "Keine MYP-Images gefunden"
    fi
    
    # Auch projektspezifische Images entfernen
    PROJECT_IMAGES=$(docker images --filter "reference=projektarbeit-myp*" --format "{{.Repository}}:{{.Tag}}" 2>/dev/null || true)
    if [[ -n "$PROJECT_IMAGES" ]]; then
        echo "$PROJECT_IMAGES" | xargs docker rmi -f &> /dev/null
        print_success "Projekt-Images entfernt: $PROJECT_IMAGES"
    fi
} || {
    print_warning "Fehler beim Entfernen der Images"
}

# MYP-Netzwerke entfernen
print_step "Entferne MYP-Netzwerke..."
{
    MYP_NETWORKS=$(docker network ls --filter "name=myp" --format "{{.Name}}" 2>/dev/null || true)
    if [[ -n "$MYP_NETWORKS" ]]; then
        echo "$MYP_NETWORKS" | xargs docker network rm &> /dev/null
        print_success "MYP-Netzwerke entfernt: $MYP_NETWORKS"
    else
        echo "Keine MYP-Netzwerke gefunden"
    fi
} || {
    print_warning "Fehler beim Entfernen der Netzwerke"
}

# Volumes entfernen (nur wenn nicht explizit ausgeschlossen)
if [[ -z "$KEEP_VOLUMES_FLAG" ]]; then
    print_step "Entferne MYP-Volumes..."
    {
        MYP_VOLUMES=$(docker volume ls --filter "name=myp" --format "{{.Name}}" 2>/dev/null || true)
        if [[ -n "$MYP_VOLUMES" ]]; then
            echo "$MYP_VOLUMES" | xargs docker volume rm &> /dev/null
            print_success "MYP-Volumes entfernt: $MYP_VOLUMES"
        else
            echo "Keine MYP-Volumes gefunden"
        fi
        
        # Auch projektspezifische Volumes
        PROJECT_VOLUMES=$(docker volume ls --filter "name=projektarbeit-myp" --format "{{.Name}}" 2>/dev/null || true)
        if [[ -n "$PROJECT_VOLUMES" ]]; then
            echo "$PROJECT_VOLUMES" | xargs docker volume rm &> /dev/null
            print_success "Projekt-Volumes entfernt: $PROJECT_VOLUMES"
        fi
    } || {
        print_warning "Fehler beim Entfernen der Volumes"
    }
else
    print_warning "Volumes werden beibehalten (--keep-volumes gesetzt)"
fi

# Unbenutzte Ressourcen bereinigen
print_step "Bereinige unbenutzte Docker-Ressourcen..."
{
    docker system prune -f &> /dev/null
    print_success "System-Bereinigung abgeschlossen"
} || {
    print_warning "Fehler bei der System-Bereinigung"
}

# Build-Cache bereinigen
print_step "Bereinige Build-Cache..."
{
    docker builder prune -f &> /dev/null
    print_success "Build-Cache bereinigt"
} || {
    print_warning "Fehler beim Bereinigen des Build-Caches"
}

# Lokale Dateien bereinigen
print_step "Bereinige lokale temporäre Dateien..."
{
    # Logs bereinigen
    if [[ -d "logs" ]]; then
        find logs -type f -delete 2>/dev/null || true
        echo "  Logs bereinigt"
    fi
    
    # Backend instance bereinigen (außer bei keep-volumes)
    if [[ -z "$KEEP_VOLUMES_FLAG" && -d "backend/instance" ]]; then
        find backend/instance -type f -delete 2>/dev/null || true
        echo "  Backend-Instance bereinigt"
    fi
    
    # Frontend build artifacts bereinigen
    if [[ -d "frontend/.next" ]]; then
        rm -rf frontend/.next 2>/dev/null || true
        echo "  Frontend-Build-Artifacts bereinigt"
    fi
    
    if [[ -d "frontend/out" ]]; then
        rm -rf frontend/out 2>/dev/null || true
        echo "  Frontend-Output bereinigt"
    fi
    
    # Node modules cache bereinigen (optional)
    if [[ -d "frontend/node_modules/.cache" ]]; then
        rm -rf frontend/node_modules/.cache 2>/dev/null || true
        echo "  Frontend-Cache bereinigt"
    fi
    
    print_success "Lokale Dateien bereinigt"
} || {
    print_warning "Fehler beim Bereinigen lokaler Dateien"
}

# Übersicht der verbliebenen Ressourcen (wenn Verbose)
if [[ -n "$VERBOSE_FLAG" ]]; then
    print_step "Verbliebene Docker-Ressourcen:"
    
    echo "Container:"
    docker ps -a --format "table {{.Names}}\t{{.Image}}\t{{.Status}}" 2>/dev/null || echo "Keine Container"
    
    echo -e "\nImages:"
    docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}" 2>/dev/null || echo "Keine Images"
    
    echo -e "\nVolumes:"
    docker volume ls --format "table {{.Name}}\t{{.Driver}}" 2>/dev/null || echo "Keine Volumes"
    
    echo -e "\nNetzwerke:"
    docker network ls --format "table {{.Name}}\t{{.Driver}}" 2>/dev/null || echo "Keine Netzwerke"
fi

print_success "🎉 Bereinigung erfolgreich abgeschlossen!"

print_step "Empfohlene nächste Schritte:"
echo "  1. Neustart mit: ./infrastructure/scripts/start.sh"
echo "  2. Oder bei Problemen: ./infrastructure/scripts/start.sh dev --clean --no-cache"

# Speicherplatz-Ersparnis anzeigen
print_step "Docker System-Analyse:"
{
    docker system df 2>/dev/null || print_warning "System-Analyse fehlgeschlagen"
}