Fix-PSModulePath.ps1

[CmdletBinding()]
param(
    [switch]$Apply,
    [switch]$Cleanup
)

# Neue Modulpfade (außerhalb von OneDrive)
function Get-NewModulePath {
    return @{
        "PowerShell"       = Join-Path $env:LOCALAPPDATA "PowerShell\Modules"
        "WindowsPowerShell" = Join-Path $env:LOCALAPPDATA "WindowsPowerShell\Modules"
    }
}

# OneDrive-Modulpfade (zu entfernen)
function Get-OneDriveModulePath {
    $paths = @()
    $roots = @($env:OneDrive, $env:OneDriveCommercial) | Where-Object { $_ }
    $docNames = @("Documents", "Dokumente")
    $moduleTypes = @("PowerShell\Modules", "WindowsPowerShell\Modules")

    foreach ($root in $roots) {
        foreach ($doc in $docNames) {
            foreach ($type in $moduleTypes) {
                $path = Join-Path (Join-Path $root $doc) $type
                if (Test-Path $path) {
                    $paths += $path
                }
            }
        }
    }
    return $paths
}

# Prüft ob ein Pfad ein OneDrive-Pfad ist
function Test-OneDrivePath {
    param([string]$Path)
    return ($Path -match '(?i)\\OneDrive( - [^\\]+)?(\\|$)')
}

# Filtert OneDrive-Pfade und fügt neue hinzu
function Get-CleanedModulePath {
    param(
        [string]$CurrentPath,
        [hashtable]$NewPaths
    )

    $currentPaths = @()
    if ($CurrentPath) {
        $currentPaths = ($CurrentPath -split ';') | Where-Object { $_ }
    }

    $filteredPaths = $currentPaths | Where-Object { -not (Test-OneDrivePath $_) }
    $newPathList = @()

    foreach ($newPath in $NewPaths.Values) {
        $normalized = $newPath.TrimEnd('\').ToLowerInvariant()
        $exists = $filteredPaths | Where-Object { $_.TrimEnd('\').ToLowerInvariant() -eq $normalized }
        if (-not $exists) {
            $newPathList += $newPath
        }
    }

    $finalPaths = @($newPathList) + @($filteredPaths) | Where-Object { $_ }
    return @{
        CurrentPaths = $currentPaths
        FinalPaths   = $finalPaths
        NewUserPath  = ($finalPaths -join ';')
    }
}

# Hauptlogik
function Invoke-PSModulePathFix {
    param(
        [switch]$Apply,
        [switch]$Cleanup
    )

    $newPaths = Get-NewModulePath
    $userPathRaw = [System.Environment]::GetEnvironmentVariable("PSModulePath", "User")
    $result = Get-CleanedModulePath -CurrentPath $userPathRaw -NewPaths $newPaths

    $currentPaths = $result.CurrentPaths
    $finalPaths = $result.FinalPaths
    $newUserPath = $result.NewUserPath

    # Status anzeigen
    Write-Host "=== PSModulePath Fix ===" -ForegroundColor Cyan
    Write-Host ""
    Write-Host "Aktueller User-PSModulePath:" -ForegroundColor Yellow
    if ($currentPaths.Count -eq 0) {
        Write-Host "  (leer)" -ForegroundColor DarkGray
    } else {
        $currentPaths | ForEach-Object {
            $color = if (Test-OneDrivePath $_) { "Red" } else { "White" }
            Write-Host "  $_" -ForegroundColor $color
        }
    }

    Write-Host ""
    Write-Host "Neuer User-PSModulePath:" -ForegroundColor Yellow
    $finalPaths | ForEach-Object { Write-Host "  $_" -ForegroundColor Green }

    # OneDrive-Ordner finden
    $oneDriveFolders = Get-OneDriveModulePath
    if ($oneDriveFolders.Count -gt 0) {
        Write-Host ""
        Write-Host "OneDrive-Modulordner gefunden:" -ForegroundColor Yellow
        $oneDriveFolders | ForEach-Object { Write-Host "  $_" -ForegroundColor Red }
    }

    if ($Apply) {
        # Neue Verzeichnisse erstellen
        foreach ($path in $newPaths.Values) {
            if (-not (Test-Path $path)) {
                New-Item -ItemType Directory -Path $path -Force | Out-Null
                Write-Host "Erstellt: $path" -ForegroundColor Green
            }
        }

        # User-Level PSModulePath setzen
        [System.Environment]::SetEnvironmentVariable("PSModulePath", $newUserPath, "User")
        Write-Host ""
        Write-Host "User-PSModulePath aktualisiert." -ForegroundColor Green

        # Aktuelle Session aktualisieren
        $machinePath = [System.Environment]::GetEnvironmentVariable("PSModulePath", "Machine")
        $env:PSModulePath = (@($newUserPath, $machinePath) | Where-Object { $_ }) -join ';'

        if ($Cleanup -and $oneDriveFolders.Count -gt 0) {
            Write-Host ""
            foreach ($folder in $oneDriveFolders) {
                $items = @(Get-ChildItem -Path $folder -ErrorAction SilentlyContinue)
                if ($items.Count -gt 0) {
                    Write-Host "WARNUNG: $folder enthält $($items.Count) Module:" -ForegroundColor Yellow
                    $items | ForEach-Object { Write-Host "  - $($_.Name)" -ForegroundColor DarkYellow }
                }
                $confirm = Read-Host "Löschen: $folder ? (ja/nein)"
                if ($confirm -match '^(ja|j|yes|y)$') {
                    Remove-Item -Path $folder -Recurse -Force -ErrorAction SilentlyContinue
                    Write-Host "Gelöscht: $folder" -ForegroundColor Green
                } else {
                    Write-Host "Übersprungen: $folder" -ForegroundColor Yellow
                }
            }
        }

        Write-Host ""
        Write-Host "Fertig. Bitte PowerShell neu starten." -ForegroundColor Green
    } else {
        Write-Host ""
        Write-Host "Simulation - keine Änderungen. Verwende -Apply zum Ausführen." -ForegroundColor Yellow
        if ($oneDriveFolders.Count -gt 0) {
            Write-Host "Verwende -Apply -Cleanup um OneDrive-Ordner zu löschen." -ForegroundColor Yellow
        }
    }
}

# Nur ausführen wenn nicht dot-sourced (ermöglicht Testen)
if ($MyInvocation.InvocationName -ne '.') {
    Invoke-PSModulePathFix -Apply:$Apply -Cleanup:$Cleanup
}