# 🧹 MYP Bereinigungs-Skript (Windows PowerShell)
# Vollständige Bereinigung aller Docker-Ressourcen

param(
    [switch]$Force,
    [switch]$KeepVolumes,
    [switch]$Verbose
)

$ErrorActionPreference = "Stop"

# Farbkodierte Ausgabe
function Write-ColoredOutput {
    param(
        [string]$Message,
        [string]$Color = "White"
    )
    Write-Host $Message -ForegroundColor $Color
}

function Write-Step {
    param([string]$Message)
    Write-ColoredOutput "🔧 $Message" "Cyan"
}

function Write-Success {
    param([string]$Message)
    Write-ColoredOutput "✅ $Message" "Green"
}

function Write-Warning {
    param([string]$Message)
    Write-ColoredOutput "⚠️ $Message" "Yellow"
}

function Write-Error {
    param([string]$Message)
    Write-ColoredOutput "❌ $Message" "Red"
}

# Header
Write-ColoredOutput @"
╔═══════════════════════════════════════════════════════╗
║              🧹 MYP Bereinigung                        ║
║           Docker-Ressourcen aufräumen                 ║
╚═══════════════════════════════════════════════════════╝
"@ "Magenta"

# Bestätigung anfordern (außer bei -Force)
if (-not $Force) {
    Write-Warning "WARNUNG: Diese Aktion wird alle MYP-Container, Images und Netzwerke entfernen!"
    if (-not $KeepVolumes) {
        Write-Warning "Auch alle Volumes (einschließlich Datenbanken) werden gelöscht!"
    }
    
    $confirm = Read-Host "Möchten Sie fortfahren? (j/N)"
    if ($confirm -ne "j" -and $confirm -ne "J") {
        Write-Host "Bereinigung abgebrochen."
        exit 0
    }
}

# Docker Verfügbarkeit prüfen
try {
    $dockerInfo = docker info 2>$null
    if ($LASTEXITCODE -ne 0) {
        Write-Error "Docker ist nicht verfügbar oder läuft nicht."
        exit 1
    }
}
catch {
    Write-Error "Fehler beim Zugriff auf Docker: $_"
    exit 1
}

# Aktuelle Docker Compose Services stoppen
Write-Step "Stoppe Docker Compose Services..."
try {
    $composeFiles = @("docker-compose.yml")
    if (Test-Path "docker-compose.dev.yml") {
        $composeFiles += "docker-compose.dev.yml"
    }
    if (Test-Path "docker-compose.override.yml") {
        $composeFiles += "docker-compose.override.yml"
    }
    
    $composeArgs = $composeFiles | ForEach-Object { "-f", $_ }
    
    docker-compose @composeArgs down --remove-orphans 2>$null
    Write-Success "Services gestoppt"
}
catch {
    Write-Warning "Fehler beim Stoppen der Services: $_"
}

# MYP-spezifische Container entfernen
Write-Step "Entferne MYP-Container..."
try {
    $mypContainers = docker ps -a --filter "name=myp-" --format "{{.Names}}" 2>$null
    if ($mypContainers) {
        docker rm -f $mypContainers 2>$null
        Write-Success "MYP-Container entfernt: $($mypContainers -join ', ')"
    } else {
        Write-Host "Keine MYP-Container gefunden"
    }
}
catch {
    Write-Warning "Fehler beim Entfernen der Container: $_"
}

# MYP-spezifische Images entfernen
Write-Step "Entferne MYP-Images..."
try {
    $mypImages = docker images --filter "reference=*myp*" --format "{{.Repository}}:{{.Tag}}" 2>$null
    if ($mypImages) {
        docker rmi -f $mypImages 2>$null
        Write-Success "MYP-Images entfernt: $($mypImages -join ', ')"
    } else {
        Write-Host "Keine MYP-Images gefunden"
    }
    
    # Auch projektspezifische Images entfernen
    $projectImages = docker images --filter "reference=projektarbeit-myp*" --format "{{.Repository}}:{{.Tag}}" 2>$null
    if ($projectImages) {
        docker rmi -f $projectImages 2>$null
        Write-Success "Projekt-Images entfernt: $($projectImages -join ', ')"
    }
}
catch {
    Write-Warning "Fehler beim Entfernen der Images: $_"
}

# MYP-Netzwerke entfernen
Write-Step "Entferne MYP-Netzwerke..."
try {
    $mypNetworks = docker network ls --filter "name=myp" --format "{{.Name}}" 2>$null
    if ($mypNetworks) {
        docker network rm $mypNetworks 2>$null
        Write-Success "MYP-Netzwerke entfernt: $($mypNetworks -join ', ')"
    } else {
        Write-Host "Keine MYP-Netzwerke gefunden"
    }
}
catch {
    Write-Warning "Fehler beim Entfernen der Netzwerke: $_"
}

# Volumes entfernen (nur wenn nicht explizit ausgeschlossen)
if (-not $KeepVolumes) {
    Write-Step "Entferne MYP-Volumes..."
    try {
        $mypVolumes = docker volume ls --filter "name=myp" --format "{{.Name}}" 2>$null
        if ($mypVolumes) {
            docker volume rm $mypVolumes 2>$null
            Write-Success "MYP-Volumes entfernt: $($mypVolumes -join ', ')"
        } else {
            Write-Host "Keine MYP-Volumes gefunden"
        }
        
        # Auch projektspezifische Volumes
        $projectVolumes = docker volume ls --filter "name=projektarbeit-myp" --format "{{.Name}}" 2>$null
        if ($projectVolumes) {
            docker volume rm $projectVolumes 2>$null
            Write-Success "Projekt-Volumes entfernt: $($projectVolumes -join ', ')"
        }
    }
    catch {
        Write-Warning "Fehler beim Entfernen der Volumes: $_"
    }
} else {
    Write-Warning "Volumes werden beibehalten (--KeepVolumes gesetzt)"
}

# Unbenutzte Ressourcen bereinigen
Write-Step "Bereinige unbenutzte Docker-Ressourcen..."
try {
    docker system prune -f 2>$null
    Write-Success "System-Bereinigung abgeschlossen"
}
catch {
    Write-Warning "Fehler bei der System-Bereinigung: $_"
}

# Build-Cache bereinigen
Write-Step "Bereinige Build-Cache..."
try {
    docker builder prune -f 2>$null
    Write-Success "Build-Cache bereinigt"
}
catch {
    Write-Warning "Fehler beim Bereinigen des Build-Caches: $_"
}

# Lokale Dateien bereinigen
Write-Step "Bereinige lokale temporäre Dateien..."
try {
    # Logs bereinigen
    if (Test-Path "logs") {
        Get-ChildItem "logs" -File -Recurse | Remove-Item -Force -ErrorAction SilentlyContinue
        Write-Host "  Logs bereinigt"
    }
    
    # Backend instance bereinigen (außer bei KeepVolumes)
    if (-not $KeepVolumes -and (Test-Path "backend/instance")) {
        Get-ChildItem "backend/instance" -File -Recurse | Remove-Item -Force -ErrorAction SilentlyContinue
        Write-Host "  Backend-Instance bereinigt"
    }
    
    # Frontend build artifacts bereinigen
    if (Test-Path "frontend/.next") {
        Remove-Item "frontend/.next" -Recurse -Force -ErrorAction SilentlyContinue
        Write-Host "  Frontend-Build-Artifacts bereinigt"
    }
    
    if (Test-Path "frontend/out") {
        Remove-Item "frontend/out" -Recurse -Force -ErrorAction SilentlyContinue
        Write-Host "  Frontend-Output bereinigt"
    }
    
    Write-Success "Lokale Dateien bereinigt"
}
catch {
    Write-Warning "Fehler beim Bereinigen lokaler Dateien: $_"
}

# Übersicht der verbliebenen Ressourcen (wenn Verbose)
if ($Verbose) {
    Write-Step "Verbliebene Docker-Ressourcen:"
    
    Write-Host "Container:"
    docker ps -a --format "table {{.Names}}\t{{.Image}}\t{{.Status}}" 2>$null | Out-Host
    
    Write-Host "`nImages:"
    docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}" 2>$null | Out-Host
    
    Write-Host "`nVolumes:"
    docker volume ls --format "table {{.Name}}\t{{.Driver}}" 2>$null | Out-Host
    
    Write-Host "`nNetzwerke:"
    docker network ls --format "table {{.Name}}\t{{.Driver}}" 2>$null | Out-Host
}

Write-Success "🎉 Bereinigung erfolgreich abgeschlossen!"

Write-Step "Empfohlene nächste Schritte:"
Write-Host "  1. Neustart mit: .\infrastructure\scripts\start.ps1"
Write-Host "  2. Oder bei Problemen: .\infrastructure\scripts\start.ps1 dev --clean --no-cache"

# Speicherplatz-Ersparnis anzeigen
Write-Step "Führe Docker System-Analyse durch..."
try {
    docker system df 2>$null | Out-Host
}
catch {
    Write-Warning "System-Analyse fehlgeschlagen"
}