Private/Utilities/Resolve-PIMDependencies.ps1

function Resolve-PIMDependencies {
    <#
    .SYNOPSIS
        Automatically resolves all PIM module dependencies with minimal user intervention.
     
    .DESCRIPTION
        Performs comprehensive dependency resolution including:
        - Automatic conflict detection and resolution
        - Missing module installation
        - Version compatibility checking
        - Intelligent retry mechanisms
     
    .PARAMETER Force
        Skip confirmation prompts for automatic operations.
     
    .PARAMETER MaxRetries
        Maximum number of retry attempts for failed operations (default: 3).
     
    .EXAMPLE
        Resolve-PIMDependencies
        Automatically resolve all dependencies with user prompts.
         
    .EXAMPLE
        Resolve-PIMDependencies -Force
        Fully automated dependency resolution without prompts.
     
    .OUTPUTS
        PSCustomObject with resolution status and actions performed
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [switch]$Force,
        
        [Parameter()]
        [int]$MaxRetries = 3
    )
    
    $result = [PSCustomObject]@{
        Success = $false
        RequiredRestart = $false
        ActionsPerformed = [System.Collections.ArrayList]::new()
        Errors = [System.Collections.ArrayList]::new()
        RetryCount = 0
    }
    
    Write-Verbose "Starting automatic dependency resolution..."
    
    for ($attempt = 1; $attempt -le $MaxRetries; $attempt++) {
        $result.RetryCount = $attempt - 1
        
        try {
            Write-Verbose "Attempt $attempt/$MaxRetries - Checking current state..."
            
            # Step 1: Check for version conflicts
            Write-Verbose "Checking for version conflicts..."
            $conflictCheck = Test-ModuleVersionConflicts -RequiredModuleVersions $script:RequiredModuleVersions -AutoResolve:$Force
            
            if ($conflictCheck.HasConflicts -and -not $conflictCheck.AutoResolutionSuccess) {
                Write-Verbose "Version conflicts detected"
                
                if (-not $Force) {
                    Write-Host "⚠️ Version conflicts detected. Auto-resolve? (y/N): " -ForegroundColor Yellow -NoNewline
                    $userChoice = Read-Host
                    if ($userChoice -ne 'y') {
                        $null = $result.Errors.Add("User declined automatic conflict resolution")
                        break
                    }
                }
                
                # Retry conflict resolution with auto-resolve
                Write-Verbose "Auto-resolving conflicts..."
                $conflictCheck = Test-ModuleVersionConflicts -RequiredModuleVersions $script:RequiredModuleVersions -AutoResolve -Force
                
                if ($conflictCheck.AutoResolutionSuccess) {
                    Write-Verbose "Conflicts resolved successfully"
                    foreach ($action in $conflictCheck.ActionsPerformed) {
                        $null = $result.ActionsPerformed.Add($action)
                    }
                }
                else {
                    Write-Verbose "Automatic conflict resolution failed"
                    $null = $result.Errors.Add("Automatic conflict resolution failed")
                    $result.RequiredRestart = $true
                    break
                }
            }
            else {
                Write-Verbose "No version conflicts detected"
            }
            
            # Step 2: Check and install missing modules
            Write-Verbose "Checking module availability..."
            $missingModules = [System.Collections.ArrayList]::new()
            
            # Suppress verbose output during module checks
            $originalVerbosePreference = $VerbosePreference
            $VerbosePreference = 'SilentlyContinue'
            
            foreach ($moduleName in $script:RequiredModuleVersions.Keys) {
                $requiredVersion = [version]$script:RequiredModuleVersions[$moduleName]
                $availableModule = Get-Module -ListAvailable -Name $moduleName | 
                    Where-Object { $_.Version -ge $requiredVersion } | 
                    Select-Object -First 1
                
                if (-not $availableModule) {
                    $null = $missingModules.Add(@{
                        Name = $moduleName
                        RequiredVersion = $requiredVersion
                    })
                }
            }
            
            # Restore verbose preference
            $VerbosePreference = $originalVerbosePreference
            
            if ($missingModules.Count -gt 0) {
                Write-Verbose "Missing modules detected: $($missingModules.Count)"
                
                if (-not $Force) {
                    Write-Host "📥 Missing modules detected. Install automatically? (y/N): " -ForegroundColor Yellow -NoNewline
                    $userChoice = Read-Host
                    if ($userChoice -ne 'y') {
                        $null = $result.Errors.Add("User declined automatic module installation")
                        break
                    }
                }
                
                Write-Verbose "Installing missing modules..."
                try {
                    Install-RequiredModules -Force:$Force
                    $null = $result.ActionsPerformed.Add("Installed missing modules: $($missingModules.Name -join ', ')")
                    Write-Verbose "Modules installed successfully"
                }
                catch {
                    Write-Verbose "Module installation failed: $($_.Exception.Message)"
                    $null = $result.Errors.Add("Module installation failed: $($_.Exception.Message)")
                    break
                }
            }
            else {
                Write-Verbose "All required modules are available"
            }
            
            # Step 3: Final verification
            Write-Verbose "Performing final verification..."
            $finalCheck = Test-PIMDependencies
            
            if ($finalCheck.ReadyForActivation) {
                Write-Verbose "Final verification successful"
                $result.Success = $true
                $null = $result.ActionsPerformed.Add("All dependencies resolved successfully")
                Write-Verbose "All dependencies resolved! PIM Activation is ready."
                break
            }
            else {
                Write-Verbose "Final check indicates remaining issues: $($finalCheck.OverallStatus)"
                
                if ($attempt -eq $MaxRetries) {
                    $null = $result.Errors.Add("Maximum retry attempts reached. Issues remain: $($finalCheck.OverallStatus)")
                }
            }
        }
        catch {
            Write-Verbose "Attempt $attempt failed: $($_.Exception.Message)"
            $null = $result.Errors.Add("Attempt $attempt failed: $($_.Exception.Message)")
            
            if ($attempt -eq $MaxRetries) {
                Write-Verbose "Maximum retry attempts reached. Manual intervention may be required."
            }
            else {
                Write-Verbose "Retrying in 2 seconds..."
                Start-Sleep -Seconds 2
            }
        }
    }
    
    # Display minimal results - only show errors or important info
    if (-not $result.Success -and $result.Errors.Count -gt 0) {
        Write-Host "`n❌ Dependency resolution failed:" -ForegroundColor Red
        foreach ($errorMessage in $result.Errors) {
            Write-Host " $errorMessage" -ForegroundColor Red
        }
    }
    
    if ($result.RequiredRestart) {
        Write-Host "`n⚠️ PowerShell restart required. After restart, run: Start-PIMActivation" -ForegroundColor Yellow
    }
    
    Write-Verbose "Dependency resolution completed. Success: $($result.Success)"
    if ($result.ActionsPerformed.Count -gt 0) {
        Write-Verbose "Actions performed: $($result.ActionsPerformed -join '; ')"
    }
    
    return $result
}