install.ps1

# DevOps Environment Toolkit - Enhanced Windows Installation Script
# Author: H A R S H H A A
# License: MIT
# Version: 2.0.0

# Set execution policy for current session
Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process -Force

# Global variables with consistent naming
$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
$LogFile = "$env:USERPROFILE\.devops-toolkit-install.log"
$BackupDir = "$env:USERPROFILE\.devops-toolkit-backup"
$InstallTimestamp = Get-Date -Format "yyyyMMdd_HHmmss"
$Verbose = $false
$DryRun = $false
$SkipConfirmation = $false
$SelectiveInstall = $false

# Installation flags (consistent naming)
$InstallGit = $false
$InstallDocker = $false
$InstallK8s = $false
$InstallTerraform = $false
$InstallAnsible = $false
$InstallVSCode = $false
$InstallAwsCli = $false
$InstallAzureCli = $false

# System information
$OSVersion = $null
$OSName = ""

# Colors for output
$Red = "Red"
$Green = "Green"
$Yellow = "Yellow"
$Blue = "Blue"
$Magenta = "Magenta"
$Cyan = "Cyan"
$White = "White"

# ASCII Art Banner
function Show-Banner {
    Write-Host ""
    Write-Host "    ╔══════════════════════════════════════════════════════════════╗" -ForegroundColor $Cyan
    Write-Host "    ║                                                              ║" -ForegroundColor $Cyan
    Write-Host "    ║    🚀 DevOps Environment Toolkit - Enhanced Installer 🚀     ║" -ForegroundColor $Cyan
    Write-Host "    ║                                                              ║" -ForegroundColor $Cyan
    Write-Host "    ║    Version 2.0.0 - Advanced Features & Error Recovery       ║" -ForegroundColor $Cyan
    Write-Host "    ║                                                              ║" -ForegroundColor $Cyan
    Write-Host "    ╚══════════════════════════════════════════════════════════════╝" -ForegroundColor $Cyan
    Write-Host ""
}

# Enhanced logging system
function Initialize-Logging {
    $LogDir = Split-Path -Parent $LogFile
    if (-not (Test-Path $LogDir)) {
        New-Item -ItemType Directory -Path $LogDir -Force | Out-Null
    }
    
    $LogHeader = @"
=== DevOps Toolkit Installation Log - $(Get-Date) ===
Script Version: 2.0.0
OS: $([System.Environment]::OSVersion.VersionString)
User: $env:USERNAME
===============================================
"@
    
    $LogHeader | Out-File -FilePath $LogFile -Encoding UTF8
}

function Write-LogFile {
    param(
        [string]$Level,
        [string]$Message
    )
    
    $LogEntry = "[$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')] [$Level] $Message"
    $LogEntry | Out-File -FilePath $LogFile -Append -Encoding UTF8
}

# Progress tracking
$ProgressTotal = 0
$ProgressCurrent = 0

function Initialize-Progress {
    param([int]$Total)
    $script:ProgressTotal = $Total
    $script:ProgressCurrent = 0
}

function Update-Progress {
    $script:ProgressCurrent++
    $Percentage = [math]::Round(($ProgressCurrent * 100) / $ProgressTotal)
    
    Write-Host "`r[PROGRESS] $ProgressCurrent/$ProgressTotal ($Percentage%) - " -NoNewline -ForegroundColor $Blue
    
    # Create progress bar
    $BarLength = 30
    $FilledLength = [math]::Round(($Percentage * $BarLength) / 100)
    Write-Host "[" -NoNewline
    for ($i = 0; $i -lt $FilledLength; $i++) { Write-Host "█" -NoNewline }
    for ($i = $FilledLength; $i -lt $BarLength; $i++) { Write-Host "░" -NoNewline }
    Write-Host "]" -NoNewline
}

# Rollback and cleanup functionality
function Invoke-RollbackInstallation {
    Write-Info "Rolling back installation..."
    
    # Remove installed packages based on what was attempted
    if ($InstallDocker) {
        Write-Info "Removing Docker packages..."
        Invoke-Command "choco uninstall docker-desktop docker-compose -y" "Removed Docker packages" 2>$null
    }
    
    if ($InstallK8s) {
        Write-Info "Removing Kubernetes tools..."
        Invoke-Command "choco uninstall kubernetes-cli minikube -y" "Removed Kubernetes tools" 2>$null
    }
    
    if ($InstallTerraform) {
        Write-Info "Removing Terraform..."
        Invoke-Command "choco uninstall terraform -y" "Removed Terraform" 2>$null
    }
    
    if ($InstallAnsible) {
        Write-Info "Removing Ansible..."
        Invoke-Command "choco uninstall ansible -y" "Removed Ansible" 2>$null
    }
    
    if ($InstallVSCode) {
        Write-Info "Removing VS Code..."
        Invoke-Command "choco uninstall vscode -y" "Removed VS Code" 2>$null
    }
    
    if ($InstallAwsCli) {
        Write-Info "Removing AWS CLI..."
        Invoke-Command "choco uninstall awscli -y" "Removed AWS CLI" 2>$null
    }
    
    if ($InstallAzureCli) {
        Write-Info "Removing Azure CLI..."
        Invoke-Command "choco uninstall azure-cli -y" "Removed Azure CLI" 2>$null
    }
    
    # Remove configuration directories if they were created
    if (Test-Path "$env:USERPROFILE\.devops-toolkit") {
        Write-Info "Removing configuration directories..."
        Remove-Item -Path "$env:USERPROFILE\.devops-toolkit" -Recurse -Force -ErrorAction SilentlyContinue
    }
    
    # Restore from backup if available
    $BackupPath = "$BackupDir\$InstallTimestamp"
    if (Test-Path $BackupPath) {
        Write-Info "Restoring from backup..."
        Restore-Backup $BackupPath
    }
    
    Write-Success "Rollback completed"
}

# Cleanup temporary files
function Remove-TempFiles {
    Write-Debug "Cleaning up temporary files..."
    
    # Remove common temporary files
    $tempFiles = @(
        "$env:USERPROFILE\get-docker.sh",
        "$env:USERPROFILE\terraform.zip",
        "$env:USERPROFILE\kubectl.exe",
        "$env:USERPROFILE\minikube.exe",
        "$env:USERPROFILE\terraform.exe"
    )
    
    foreach ($file in $tempFiles) {
        if (Test-Path $file) {
            Remove-Item -Path $file -Force -ErrorAction SilentlyContinue
        }
    }
    
    Write-Debug "Temporary files cleaned up"
}

# Enhanced error handling and recovery
function Handle-Error {
    param(
        [string]$ErrorMessage,
        [string]$Command
    )
    
    Write-Error "Error occurred: $ErrorMessage"
    Write-LogFile "ERROR" "Installation failed: $ErrorMessage (Command: $Command)"
    
    Write-Host "Installation failed! Check the log file: $LogFile" -ForegroundColor $Red
    
    # Offer rollback option
    if (-not $DryRun) {
        Write-Host ""
        $Response = Read-Host "Do you want to rollback the installation? (y/N)"
        if ($Response -eq "y" -or $Response -eq "Y") {
            Invoke-RollbackInstallation
        }
    }
    
    Remove-TempFiles
    Write-Host "You can try to recover by running: $($MyInvocation.MyCommand.Path) -Recover" -ForegroundColor $Yellow
    exit 1
}

# Backup and restore functionality
function New-Backup {
    Write-Info "Creating backup of existing configurations..."
    
    $BackupPath = "$BackupDir\$InstallTimestamp"
    if (-not (Test-Path $BackupPath)) {
        New-Item -ItemType Directory -Path $BackupPath -Force | Out-Null
    }
    
    # Backup existing configurations
    if (Test-Path "$env:USERPROFILE\.devops-toolkit") {
        Copy-Item -Path "$env:USERPROFILE\.devops-toolkit" -Destination $BackupPath -Recurse -Force -ErrorAction SilentlyContinue
    }
    
    # Backup PowerShell profile
    if (Test-Path $PROFILE) {
        Copy-Item -Path $PROFILE -Destination "$BackupPath\profile.ps1" -Force -ErrorAction SilentlyContinue
    }
    
    Write-Success "Backup created at: $BackupPath"
    Write-LogFile "INFO" "Backup created at: $BackupPath"
}

function Restore-Backup {
    param([string]$BackupPath)
    
    if (-not $BackupPath) {
        # Find the latest backup
        $BackupPath = Get-ChildItem -Path $BackupDir -Directory | Sort-Object LastWriteTime -Descending | Select-Object -First 1
        if ($BackupPath) {
            $BackupPath = $BackupPath.FullName
        }
    }
    
    if (-not $BackupPath -or -not (Test-Path $BackupPath)) {
        Write-Error "No backup found to restore"
        return $false
    }
    
    Write-Info "Restoring from backup: $BackupPath"
    
    # Restore configurations
    if (Test-Path "$BackupPath\.devops-toolkit") {
        Remove-Item -Path "$env:USERPROFILE\.devops-toolkit" -Recurse -Force -ErrorAction SilentlyContinue
        Copy-Item -Path "$BackupPath\.devops-toolkit" -Destination $env:USERPROFILE -Recurse -Force
    }
    
    # Restore PowerShell profile
    if (Test-Path "$BackupPath\profile.ps1") {
        Copy-Item -Path "$BackupPath\profile.ps1" -Destination $PROFILE -Force
    }
    
    Write-Success "Backup restored successfully"
    Write-LogFile "INFO" "Backup restored from: $BackupPath"
    return $true
}

# System validation and compatibility checks
function Test-SystemCompatibility {
    Write-Info "Validating system compatibility..."
    
    # Check available disk space (need at least 5GB)
    $Drive = Get-WmiObject -Class Win32_LogicalDisk -Filter "DeviceID='C:'"
    $AvailableSpaceGB = [math]::Round($Drive.FreeSpace / 1GB, 2)
    $RequiredSpaceGB = 5
    
    if ($AvailableSpaceGB -lt $RequiredSpaceGB) {
        Write-Error "Insufficient disk space. Need at least $RequiredSpaceGB GB, have $AvailableSpaceGB GB"
        return $false
    }
    
    # Check available memory (need at least 4GB)
    $Memory = Get-WmiObject -Class Win32_ComputerSystem
    $TotalMemoryGB = [math]::Round($Memory.TotalPhysicalMemory / 1GB, 2)
    if ($TotalMemoryGB -lt 4) {
        Write-Warning "Low available memory: $TotalMemoryGB GB. Recommended: 4GB+"
    }
    
    # Check internet connectivity
    Write-Info "Checking internet connectivity..."
    try {
        $testConnection = Test-Connection -ComputerName "8.8.8.8" -Count 1 -Quiet -ErrorAction SilentlyContinue
        if (-not $testConnection) {
            # Try alternative method
            try {
                $webRequest = Invoke-WebRequest -Uri "https://www.google.com" -UseBasicParsing -TimeoutSec 5 -ErrorAction Stop
                if ($webRequest.StatusCode -ne 200) {
                    Write-Warning "Internet connection may be unstable. Some installations may fail."
                }
            }
            catch {
                Write-Warning "No internet connection detected. Some installations may fail."
                Write-Info "Continuing with installation - some tools may need manual installation"
            }
        }
    }
    catch {
        Write-Warning "Cannot verify internet connectivity. Proceeding with installation."
    }
    
    # Check Windows version
    $OSVersion = [System.Environment]::OSVersion.Version
    if ($OSVersion.Major -lt 10) {
        Write-Warning "Windows 10 or later is recommended for best compatibility"
    }
    
    Write-Success "System validation completed"
    Write-LogFile "INFO" "System validation passed"
    return $true
}

# Input validation functions
function Test-ValidInput {
    param(
        [string]$Input,
        [string]$Pattern,
        [string]$Description
    )
    
    if ([string]::IsNullOrWhiteSpace($Input)) {
        Write-Error "Empty input not allowed for $Description"
        return $false
    }
    
    if ($Pattern -and $Input -notmatch $Pattern) {
        Write-Error "Invalid input format for $Description: $Input"
        return $false
    }
    
    # Check for potentially dangerous characters
    if ($Input -match '[;&|`$(){}\[\]]') {
        Write-Error "Potentially dangerous characters detected in $Description"
        return $false
    }
    
    return $true
}

function Get-SafePath {
    param([string]$Path)
    # Remove potentially dangerous characters
    return $Path -replace '[;&|`$(){}\[\]]', '' -replace '\.', '/'
}

# Version checking and update mechanisms
function Get-LatestVersion {
    param(
        [string]$ToolName,
        [string]$CurrentVersion,
        [string]$VersionUrl
    )
    
    Write-Debug "Checking for latest version of $ToolName..."
    
    if ([string]::IsNullOrWhiteSpace($VersionUrl)) {
        Write-Debug "No version URL provided for $ToolName"
        return
    }
    
    try {
        $latestVersion = Invoke-RestMethod -Uri $VersionUrl -TimeoutSec 10 -ErrorAction Stop
        if ($latestVersion -is [array]) {
            $latestVersion = $latestVersion[0]
        }
        
        # Clean version string (remove 'v' prefix if present)
        $latestVersion = $latestVersion -replace '^v', ''
        $currentVersion = $CurrentVersion -replace '^v', ''
        
        if ($currentVersion -ne $latestVersion) {
            Write-Info "$ToolName update available: $currentVersion → $latestVersion"
            Write-LogFile "INFO" "$ToolName update available: $currentVersion → $latestVersion"
        } else {
            Write-Debug "$ToolName is up to date: $currentVersion"
        }
    }
    catch {
        Write-Debug "Could not retrieve latest version for $ToolName`: $($_.Exception.Message)"
    }
}

# Version comparison function
function Compare-Version {
    param(
        [string]$Version1,
        [string]$Version2
    )
    
    if ($Version1 -eq $Version2) {
        return 0  # Equal
    }
    
    # Split versions into arrays
    $v1Parts = $Version1 -split '\.'
    $v2Parts = $Version2 -split '\.'
    
    # Compare each part
    $maxLength = [Math]::Max($v1Parts.Length, $v2Parts.Length)
    for ($i = 0; $i -lt $maxLength; $i++) {
        $v1Part = if ($i -lt $v1Parts.Length) { [int]$v1Parts[$i] } else { 0 }
        $v2Part = if ($i -lt $v2Parts.Length) { [int]$v2Parts[$i] } else { 0 }
        
        if ($v1Part -gt $v2Part) {
            return 1  # Version1 > Version2
        } elseif ($v1Part -lt $v2Part) {
            return 2  # Version1 < Version2
        }
    }
    
    return 0  # Equal
}

# Enhanced logging functions with file logging
function Write-Info {
    param([string]$Message)
    Write-Host "[INFO] $Message" -ForegroundColor $Blue
    Write-LogFile "INFO" $Message
}

function Write-Success {
    param([string]$Message)
    Write-Host "[SUCCESS] $Message" -ForegroundColor $Green
    Write-LogFile "SUCCESS" $Message
}

function Write-Warning {
    param([string]$Message)
    Write-Host "[WARNING] $Message" -ForegroundColor $Yellow
    Write-LogFile "WARNING" $Message
}

function Write-Error {
    param([string]$Message)
    Write-Host "[ERROR] $Message" -ForegroundColor $Red
    Write-LogFile "ERROR" $Message
}

function Write-Debug {
    param([string]$Message)
    if ($Verbose) {
        Write-Host "[DEBUG] $Message" -ForegroundColor $Magenta
        Write-LogFile "DEBUG" $Message
    }
}

# Command line argument parsing
function Parse-Arguments {
    param([string[]]$Arguments)
    
    for ($i = 0; $i -lt $Arguments.Length; $i++) {
        switch ($Arguments[$i]) {
            "-Verbose" { $script:Verbose = $true }
            "-DryRun" { $script:DryRun = $true }
            "-SkipConfirmation" { $script:SkipConfirmation = $true }
            "-Selective" { $script:SelectiveInstall = $true }
            "-Recover" { 
                Restore-Backup
                exit 0
            }
            "-Help" { 
                Show-Help
                exit 0
            }
            "-Version" {
                Write-Host "DevOps Environment Toolkit Installer v2.0.0"
                exit 0
            }
            default {
                Write-Error "Unknown option: $($Arguments[$i])"
                Show-Help
                exit 1
            }
        }
    }
}

function Show-Help {
    Write-Host "DevOps Environment Toolkit - Enhanced Installer" -ForegroundColor $White
    Write-Host ""
    Write-Host "Usage: .\install.ps1 [OPTIONS]" -ForegroundColor $Cyan
    Write-Host ""
    Write-Host "Options:" -ForegroundColor $Cyan
    Write-Host "  -Verbose           Enable verbose output" -ForegroundColor $Yellow
    Write-Host "  -DryRun            Show what would be installed without actually installing" -ForegroundColor $Yellow
    Write-Host "  -SkipConfirmation  Skip confirmation prompts" -ForegroundColor $Yellow
    Write-Host "  -Selective         Enable selective installation menu" -ForegroundColor $Yellow
    Write-Host "  -Recover           Restore from backup" -ForegroundColor $Yellow
    Write-Host "  -Help              Show this help message" -ForegroundColor $Yellow
    Write-Host "  -Version           Show version information" -ForegroundColor $Yellow
    Write-Host ""
    Write-Host "Examples:" -ForegroundColor $Cyan
    Write-Host "  .\install.ps1                      # Standard installation" -ForegroundColor $Yellow
    Write-Host "  .\install.ps1 -Verbose -Selective # Verbose selective installation" -ForegroundColor $Yellow
    Write-Host "  .\install.ps1 -DryRun             # Preview installation" -ForegroundColor $Yellow
    Write-Host "  .\install.ps1 -Recover            # Restore from backup" -ForegroundColor $Yellow
}

# Interactive menu system
function Show-InteractiveMenu {
    Write-Host ""
    Write-Host "Selective Installation Menu" -ForegroundColor $Cyan
    Write-Host "Choose which tools to install:" -ForegroundColor $Yellow
    Write-Host ""
    
    $MenuOptions = @{
        "1" = "Git"
        "2" = "Docker & Docker Compose"
        "3" = "Kubernetes (kubectl + Minikube)"
        "4" = "Terraform"
        "5" = "Ansible"
        "6" = "VS Code"
        "7" = "AWS CLI"
        "8" = "Azure CLI"
        "9" = "All Tools (Full Installation)"
        "0" = "Exit"
    }
    
    # Show menu options
    foreach ($key in $MenuOptions.Keys | Sort-Object) {
        Write-Host "  $key) $($MenuOptions[$key])" -ForegroundColor $Yellow
    }
    
    Write-Host ""
    while ($true) {
        $Choices = Read-Host "Enter your choice (comma-separated for multiple)"
        
        # Validate input
        if (-not (Test-ValidInput -Input $Choices -Pattern "^[0-9, ]+$" -Description "menu choices")) {
            Write-Host "Invalid input. Please enter numbers only (e.g., 1,2,3 or 9)." -ForegroundColor $Red
            continue
        }
        
        # Process choices
        $ChoiceArray = $Choices -split ","
        $ValidChoices = $true
        
        foreach ($Choice in $ChoiceArray) {
            $Choice = $Choice.Trim()
            switch ($Choice) {
                "1" { $script:InstallGit = $true }
                "2" { $script:InstallDocker = $true }
                "3" { $script:InstallK8s = $true }
                "4" { $script:InstallTerraform = $true }
                "5" { $script:InstallAnsible = $true }
                "6" { $script:InstallVSCode = $true }
                "7" { $script:InstallAwsCli = $true }
                "8" { $script:InstallAzureCli = $true }
                "9" { 
                    $script:InstallGit = $true
                    $script:InstallDocker = $true
                    $script:InstallK8s = $true
                    $script:InstallTerraform = $true
                    $script:InstallAnsible = $true
                    $script:InstallVSCode = $true
                    $script:InstallAwsCli = $true
                    $script:InstallAzureCli = $true
                }
                "0" { 
                    Write-Info "Installation cancelled by user"
                    exit 0
                }
                default { 
                    Write-Warning "Invalid choice: $Choice"
                    $ValidChoices = $false
                }
            }
        }
        
        if ($ValidChoices) {
            break
        } else {
            Write-Host "Some choices were invalid. Please try again." -ForegroundColor $Red
        }
    }
}


# Confirmation prompt with enhanced options
function Confirm-Installation {
    if ($SkipConfirmation) {
        return
    }
    
    Write-Host ""
    Write-Host "Installation Summary" -ForegroundColor $Yellow
    Write-Host "The following tools will be installed:" -ForegroundColor $Cyan
    
    # Show what will be installed
    if ($InstallGit) { Write-Host "  ✓ Git" -ForegroundColor $Green }
    if ($InstallDocker) { Write-Host "  ✓ Docker & Docker Compose" -ForegroundColor $Green }
    if ($InstallK8s) { Write-Host "  ✓ Kubernetes (kubectl + Minikube)" -ForegroundColor $Green }
    if ($InstallTerraform) { Write-Host "  ✓ Terraform" -ForegroundColor $Green }
    if ($InstallAnsible) { Write-Host "  ✓ Ansible" -ForegroundColor $Green }
    if ($InstallVSCode) { Write-Host "  ✓ VS Code" -ForegroundColor $Green }
    if ($InstallAwsCli) { Write-Host "  ✓ AWS CLI" -ForegroundColor $Green }
    if ($InstallAzureCli) { Write-Host "  ✓ Azure CLI" -ForegroundColor $Green }
    
    Write-Host ""
    Write-Host "Installation options:" -ForegroundColor $Cyan
    Write-Host "  • Log file: $LogFile" -ForegroundColor $Yellow
    Write-Host "  • Backup: $BackupDir\$InstallTimestamp" -ForegroundColor $Yellow
    Write-Host "  • Verbose: $Verbose" -ForegroundColor $Yellow
    Write-Host "  • Dry run: $DryRun" -ForegroundColor $Yellow
    
    Write-Host ""
    while ($true) {
        $Response = Read-Host "Do you want to proceed with the installation? (y/N)"
        
        # Validate input
        if ([string]::IsNullOrWhiteSpace($Response)) {
            $Response = "n"
        }
        
        if ($Response -eq "y" -or $Response -eq "Y") {
            break
        } elseif ($Response -eq "n" -or $Response -eq "N" -or $Response -eq "n") {
            Write-Info "Installation cancelled by user"
            exit 0
        } else {
            Write-Host "Invalid input. Please enter 'y' or 'n'." -ForegroundColor $Red
        }
    }
}

# Secure download function with verification
function Invoke-SecureDownload {
    param(
        [string]$Url,
        [string]$Output,
        [string]$Description
    )
    
    Write-Debug "Downloading: $Url"
    
    try {
        # Use Invoke-WebRequest with security options
        $webClient = New-Object System.Net.WebClient
        $webClient.SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12
        
        # Set timeout
        $webClient.Timeout = 300000  # 5 minutes
        
        # Download with retry logic
        $maxRetries = 3
        $retryCount = 0
        
        while ($retryCount -lt $maxRetries) {
            try {
                $webClient.DownloadFile($Url, $Output)
                break
            }
            catch {
                $retryCount++
                if ($retryCount -eq $maxRetries) {
                    throw
                }
                Write-Debug "Download attempt $retryCount failed, retrying..."
                Start-Sleep -Seconds 2
            }
        }
        
        # Verify file exists and has content
        if (-not (Test-Path $Output) -or ((Get-Item $Output).Length -eq 0)) {
            Write-Error "Downloaded file is empty or missing: $Output"
            return $false
        }
        
        Write-Success "Successfully downloaded $Description"
        return $true
    }
    catch {
        Write-Error "Failed to download $Description`: $($_.Exception.Message)"
        return $false
    }
    finally {
        if ($webClient) {
            $webClient.Dispose()
        }
    }
}

# Verify file checksum if provided
function Test-FileChecksum {
    param(
        [string]$File,
        [string]$ExpectedChecksum,
        [string]$Algorithm = "SHA256"
    )
    
    if ([string]::IsNullOrWhiteSpace($ExpectedChecksum)) {
        Write-Debug "No checksum provided for verification"
        return $true
    }
    
    Write-Debug "Verifying $Algorithm checksum for $File"
    
    try {
        $fileStream = [System.IO.File]::OpenRead($File)
        $hashAlgorithm = [System.Security.Cryptography.HashAlgorithm]::Create($Algorithm)
        $hashBytes = $hashAlgorithm.ComputeHash($fileStream)
        $actualChecksum = [System.BitConverter]::ToString($hashBytes).Replace("-", "").ToLowerInvariant()
        
        if ($actualChecksum -eq $ExpectedChecksum.ToLowerInvariant()) {
            Write-Success "Checksum verification passed"
            return $true
        } else {
            Write-Error "Checksum verification failed: expected $ExpectedChecksum, got $actualChecksum"
            return $false
        }
    }
    catch {
        Write-Error "Checksum verification failed: $($_.Exception.Message)"
        return $false
    }
    finally {
        if ($fileStream) {
            $fileStream.Close()
        }
        if ($hashAlgorithm) {
            $hashAlgorithm.Dispose()
        }
    }
}
function Invoke-Command {
    param(
        [string]$Command,
        [string]$Description
    )
    
    if ($DryRun) {
        Write-Info "[DRY RUN] Would execute: $Command"
        Write-Debug "Description: $Description"
        return $true
    }
    
    Write-Debug "Executing: $Command"
    try {
        $result = Invoke-Expression $Command
        if ($LASTEXITCODE -ne 0 -and $LASTEXITCODE -ne $null) {
            Write-Error "Failed to execute: $Command (exit code: $LASTEXITCODE)"
            return $false
        }
        Write-Success $Description
        return $true
    }
    catch {
        Write-Error "Failed to execute: $Command - $($_.Exception.Message)"
        return $false
    }
}

# Check if command exists
function Test-CommandExists {
    param([string]$Command)
    try {
        $null = Get-Command $Command -ErrorAction Stop
        return $true
    }
    catch {
        return $false
    }
}

# Install Chocolatey if not present
function Install-Chocolatey {
    if (Test-CommandExists "choco") {
        Write-Info "Chocolatey is already installed"
        return
    }
    
    Write-Info "Installing Chocolatey package manager..."
    Set-ExecutionPolicy Bypass -Scope Process -Force
    [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
    iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
    
    # Refresh environment variables
    $env:Path = [System.Environment]::GetEnvironmentVariable("Path","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path","User")
    
    Write-Success "Chocolatey installed successfully"
}

# Install Git
function Install-Git {
    if (Test-CommandExists "git") {
        $gitVersion = git --version 2>$null
        if ($gitVersion) {
            $version = ($gitVersion -replace "git version ", "").Trim()
            Write-Info "Git is already installed (version: $version)"
            
            # Check for updates
            Get-LatestVersion -ToolName "Git" -CurrentVersion $version -VersionUrl "https://api.github.com/repos/git/git/releases/latest"
        } else {
            Write-Info "Git is already installed"
        }
        return
    }
    
    Write-Info "Installing Git..."
    if (Invoke-Command "choco install git -y" "Installed Git") {
        # Configure Git with helpful aliases
        Write-Info "Configuring Git aliases..."
        git config --global alias.st status
        git config --global alias.co checkout
        git config --global alias.br branch
        git config --global alias.ci commit
        git config --global alias.unstage 'reset HEAD --'
        git config --global alias.last 'log -1 HEAD'
        git config --global alias.visual '!gitk'
        git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"
        
        Write-Success "Git configured successfully"
    }
}

# Install Docker Desktop
function Install-DockerDesktop {
    if (Test-CommandExists "docker") {
        $dockerVersion = docker --version 2>$null
        if ($dockerVersion) {
            $version = ($dockerVersion -replace "Docker version ", "" -replace ",.*", "").Trim()
            Write-Info "Docker is already installed (version: $version)"
            
            # Check for updates (Docker doesn't have a simple version API, so we'll just note current version)
            Write-LogFile "INFO" "Docker version: $version"
        } else {
            Write-Info "Docker is already installed"
        }
        return
    }
    
    Write-Info "Installing Docker Desktop..."
    try {
        if (Invoke-Command "choco install docker-desktop -y" "Installed Docker Desktop") {
            Write-Warning "Please restart your computer and start Docker Desktop manually after installation"
            Write-Success "Docker Desktop installed successfully"
        } else {
            throw "Chocolatey installation failed"
        }
    }
    catch {
        Write-Error "Failed to install Docker Desktop: $($_.Exception.Message)"
        Write-Warning "Please install Docker Desktop manually from https://www.docker.com/products/docker-desktop"
        return $false
    }
}

# Install Docker Compose
function Install-DockerCompose {
    if (Test-CommandExists "docker-compose") {
        $composeVersion = docker-compose --version 2>$null
        if ($composeVersion) {
            $version = ($composeVersion -replace "Docker Compose version ", "" -replace ",.*", "").Trim()
            Write-Info "Docker Compose is already installed (version: $version)"
        } else {
            Write-Info "Docker Compose is already installed"
        }
        return
    }
    
    Write-Info "Installing Docker Compose..."
    try {
        if (Invoke-Command "choco install docker-compose -y" "Installed Docker Compose") {
            Write-Success "Docker Compose installed successfully"
        } else {
            throw "Chocolatey installation failed"
        }
    }
    catch {
        Write-Error "Failed to install Docker Compose: $($_.Exception.Message)"
        Write-Warning "Please install Docker Compose manually from https://docs.docker.com/compose/install/"
        return $false
    }
}

# Install VS Code
function Install-VSCode {
    if (Test-CommandExists "code") {
        Write-Info "VS Code is already installed"
        return
    }
    
    Write-Info "Installing VS Code..."
    choco install vscode -y
    
    Write-Success "VS Code installed successfully"
}

# Install Minikube
function Install-Minikube {
    if (Test-CommandExists "minikube") {
        Write-Info "Minikube is already installed"
        return
    }
    
    Write-Info "Installing Minikube..."
    try {
        if (Invoke-Command "choco install minikube -y" "Installed Minikube") {
            Write-Success "Minikube installed successfully"
        } else {
            throw "Chocolatey installation failed"
        }
    }
    catch {
        Write-Error "Failed to install Minikube: $($_.Exception.Message)"
        Write-Warning "Please install Minikube manually from https://minikube.sigs.k8s.io/docs/start/"
        return $false
    }
}

# Install Ansible
function Install-Ansible {
    if (Test-CommandExists "ansible") {
        Write-Info "Ansible is already installed"
        return
    }
    
    Write-Info "Installing Ansible..."
    choco install ansible -y
    
    Write-Success "Ansible installed successfully"
}

# Install Terraform (basic version for learning)
function Install-Terraform {
    if (Test-CommandExists "terraform") {
        $tfVersion = terraform --version 2>$null
        if ($tfVersion) {
            $version = ($tfVersion -replace "Terraform v", "").Trim().Split("`n")[0]
            Write-Info "Terraform is already installed (version: $version)"
        } else {
            Write-Info "Terraform is already installed"
        }
        return
    }
    
    Write-Info "Installing Terraform..."
    try {
        if (Invoke-Command "choco install terraform -y" "Installed Terraform") {
            Write-Success "Terraform installed successfully"
        } else {
            throw "Chocolatey installation failed"
        }
    }
    catch {
        Write-Error "Failed to install Terraform: $($_.Exception.Message)"
        Write-Warning "Please install Terraform manually from https://www.terraform.io/downloads"
        return $false
    }
}

# Install kubectl
function Install-Kubectl {
    if (Test-CommandExists "kubectl") {
        $kubectlVersion = kubectl version --client 2>$null
        if ($kubectlVersion) {
            $match = $kubectlVersion | Select-String "GitVersion.*v([0-9.]+)"
            if ($match) {
                $version = $match.Matches[0].Groups[1].Value
                Write-Info "kubectl is already installed (version: $version)"
            } else {
                Write-Info "kubectl is already installed"
            }
        } else {
            Write-Info "kubectl is already installed"
        }
        return
    }
    
    Write-Info "Installing kubectl..."
    try {
        if (Invoke-Command "choco install kubernetes-cli -y" "Installed kubectl") {
            Write-Success "kubectl installed successfully"
        } else {
            throw "Chocolatey installation failed"
        }
    }
    catch {
        Write-Error "Failed to install kubectl: $($_.Exception.Message)"
        Write-Warning "Please install kubectl manually from https://kubernetes.io/docs/tasks/tools/"
        return $false
    }
}


# Install AWS CLI
function Install-AWSCLI {
    if (Test-CommandExists "aws") {
        Write-Info "AWS CLI is already installed"
        return
    }
    
    Write-Info "Installing AWS CLI..."
    choco install awscli -y
    
    Write-Success "AWS CLI installed successfully"
}

# Install Azure CLI
function Install-AzureCLI {
    if (Test-CommandExists "az") {
        Write-Info "Azure CLI is already installed"
        return
    }
    
    Write-Info "Installing Azure CLI..."
    choco install azure-cli -y
    
    Write-Success "Azure CLI installed successfully"
}


# Install additional utilities
function Install-Utilities {
    Write-Info "Installing additional utilities..."
    
    $utilities = @(
        "curl",
        "wget",
        "jq",
        "tree",
        "7zip",
        "nodejs",
        "python3",
        "yarn"
    )
    
    foreach ($util in $utilities) {
        if (-not (Test-CommandExists $util)) {
            Write-Info "Installing $util..."
            choco install $util -y
        }
    }
    
    Write-Success "Utilities installed successfully"
}

# Create configuration directories
function New-ConfigDirectories {
    Write-Info "Creating configuration directories..."
    
    $configPath = "$env:USERPROFILE\.devops-toolkit"
    $directories = @(
        "$configPath",
        "$configPath\configs",
        "$configPath\configs\docker",
        "$configPath\configs\terraform",
        "$configPath\configs\ansible",
        "$configPath\configs\vscode",
        "$configPath\templates",
        "$configPath\templates\basic-web-app",
        "$configPath\templates\microservices",
        "$configPath\templates\infrastructure",
        "$configPath\scripts",
        "$configPath\examples"
    )
    
    foreach ($dir in $directories) {
        if (-not (Test-Path $dir)) {
            New-Item -ItemType Directory -Path $dir -Force | Out-Null
        }
    }
    
    Write-Success "Configuration directories created"
}

# Install VS Code extensions
function Install-VSCodeExtensions {
    Write-Info "Installing VS Code extensions..."
    
    $extensions = @(
        "ms-vscode.vscode-docker",
        "ms-kubernetes-tools.vscode-kubernetes-tools",
        "hashicorp.terraform",
        "redhat.vscode-yaml",
        "ms-python.python",
        "ms-vscode.powershell",
        "ms-vscode.vscode-json",
        "bradlc.vscode-tailwindcss",
        "esbenp.prettier-vscode",
        "ms-vscode.vscode-github-actions"
    )
    
    foreach ($extension in $extensions) {
        Write-Info "Installing extension: $extension"
        code --install-extension $extension --force
    }
    
    Write-Success "VS Code extensions installed successfully"
}

# Post-installation health checks
function Test-HealthChecks {
    Write-Info "Running post-installation health checks..."
    
    $ChecksPassed = 0
    $TotalChecks = 0
    
    # Check Git
    if ($InstallGit) {
        $TotalChecks++
        if ((Test-CommandExists "git") -and (git --version 2>$null)) {
            Write-Success "Git is working correctly"
            $ChecksPassed++
        } else {
            Write-Error "Git health check failed"
        }
    }
    
    # Check Docker
    if ($InstallDocker) {
        $TotalChecks++
        if ((Test-CommandExists "docker") -and (docker --version 2>$null)) {
            Write-Success "Docker is working correctly"
            $ChecksPassed++
        } else {
            Write-Error "Docker health check failed"
        }
    }
    
    # Check kubectl
    if ($InstallK8s) {
        $TotalChecks++
        if ((Test-CommandExists "kubectl") -and (kubectl version --client 2>$null)) {
            Write-Success "kubectl is working correctly"
            $ChecksPassed++
        } else {
            Write-Error "kubectl health check failed"
        }
    }
    
    # Check Minikube
    if ($InstallK8s) {
        $TotalChecks++
        if ((Test-CommandExists "minikube") -and (minikube version 2>$null)) {
            Write-Success "Minikube is working correctly"
            $ChecksPassed++
        } else {
            Write-Error "Minikube health check failed"
        }
    }
    
    # Check Terraform
    if ($InstallTerraform) {
        $TotalChecks++
        if ((Test-CommandExists "terraform") -and (terraform --version 2>$null)) {
            Write-Success "Terraform is working correctly"
            $ChecksPassed++
        } else {
            Write-Error "Terraform health check failed"
        }
    }
    
    # Check Ansible
    if ($InstallAnsible) {
        $TotalChecks++
        if ((Test-CommandExists "ansible") -and (ansible --version 2>$null)) {
            Write-Success "Ansible is working correctly"
            $ChecksPassed++
        } else {
            Write-Error "Ansible health check failed"
        }
    }
    
    # Check AWS CLI
    if ($InstallAwsCli) {
        $TotalChecks++
        if ((Test-CommandExists "aws") -and (aws --version 2>$null)) {
            Write-Success "AWS CLI is working correctly"
            $ChecksPassed++
        } else {
            Write-Error "AWS CLI health check failed"
        }
    }
    
    # Check Azure CLI
    if ($InstallAzureCli) {
        $TotalChecks++
        if ((Test-CommandExists "az") -and (az --version 2>$null)) {
            Write-Success "Azure CLI is working correctly"
            $ChecksPassed++
        } else {
            Write-Error "Azure CLI health check failed"
        }
    }
    
    # Summary
    Write-Host ""
    Write-Info "Health check summary: $ChecksPassed/$TotalChecks checks passed"
    
    if ($ChecksPassed -eq $TotalChecks) {
        Write-Success "All health checks passed!"
        return $true
    } else {
        Write-Warning "Some health checks failed. Check the log file for details."
        return $false
    }
}

# Generate installation report
function New-InstallationReport {
    $ReportFile = "$env:USERPROFILE\.devops-toolkit-install-report-$InstallTimestamp.txt"
    
    Write-Info "Generating installation report..."
    
    $ReportContent = @"
DevOps Environment Toolkit - Installation Report
===============================================
Installation Date: $(Get-Date)
Script Version: 2.0.0
OS: $([System.Environment]::OSVersion.VersionString)
User: $env:USERNAME
Installation Mode: $(if ($DryRun) { "Dry Run" } else { "Live Installation" })

Installed Tools:
"@
    
    if ($InstallGit) { $ReportContent += "`n- Git" }
    if ($InstallDocker) { $ReportContent += "`n- Docker & Docker Compose" }
    if ($InstallK8s) { $ReportContent += "`n- Kubernetes (kubectl + Minikube)" }
    if ($InstallTerraform) { $ReportContent += "`n- Terraform" }
    if ($InstallAnsible) { $ReportContent += "`n- Ansible" }
    if ($InstallVSCode) { $ReportContent += "`n- VS Code" }
    if ($InstallAwsCli) { $ReportContent += "`n- AWS CLI" }
    if ($InstallAzureCli) { $ReportContent += "`n- Azure CLI" }
    
    $ReportContent += @"

Configuration Files:
- Log file: $LogFile
- Backup: $BackupDir\$InstallTimestamp
- Config directory: $env:USERPROFILE\.devops-toolkit

Next Steps:
1. Restart your computer
2. Start Docker Desktop
3. Run verification script: .\verify.ps1
4. Configure your tools: Check the configs\ directory
5. Explore templates: Check the templates\ directory

For support and updates, visit: https://github.com/your-repo/devops-environment-toolkit
"@
    
    $ReportContent | Out-File -FilePath $ReportFile -Encoding UTF8
    Write-Success "Installation report generated: $ReportFile"
}

# Check if running as administrator
function Test-Administrator {
    $currentUser = [Security.Principal.WindowsIdentity]::GetCurrent()
    $principal = New-Object Security.Principal.WindowsPrincipal($currentUser)
    return $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
}

# Main installation function
function Main {
    param([string[]]$Arguments)
    
    # Parse command line arguments
    Parse-Arguments $Arguments
    
    # Initialize logging
    Initialize-Logging
    
    Show-Banner
    
    Write-Info "Starting DevOps Environment Toolkit installation..."
    Write-LogFile "INFO" "Installation started with options: VERBOSE=$Verbose, DRY_RUN=$DryRun, SELECTIVE=$SelectiveInstall"
    
    # System validation
    if (-not (Test-SystemCompatibility)) {
        Write-Error "System validation failed. Please check the requirements."
        exit 1
    }
    
    # Create backup
    if (-not $DryRun) {
        New-Backup
    }
    
    # Check if running as administrator
    if (-not (Test-Administrator)) {
        Write-Warning "This script should be run as Administrator for best results"
        if (-not $SkipConfirmation) {
            $Response = Read-Host "Do you want to continue? (y/N)"
            if ($Response -ne "y" -and $Response -ne "Y") {
                Write-Info "Installation cancelled"
                exit 1
            }
        }
    }
    
    # Show interactive menu if selective install is enabled
    if ($SelectiveInstall) {
        Show-InteractiveMenu
    } else {
        # Default to full installation
        $InstallGit = $true
        $InstallDocker = $true
        $InstallK8s = $true
        $InstallTerraform = $true
        $InstallAnsible = $true
        $InstallVSCode = $true
        $InstallAwsCli = $true
        $InstallAzureCli = $true
    }
    
    # Confirm installation
    Confirm-Installation
    
    # Calculate total steps for progress tracking
    $TotalSteps = 0
    if ($InstallGit) { $TotalSteps += 1 }
    if ($InstallDocker) { $TotalSteps += 2 }  # Docker + Docker Compose
    if ($InstallK8s) { $TotalSteps += 2 }  # kubectl + Minikube
    if ($InstallTerraform) { $TotalSteps += 1 }
    if ($InstallAnsible) { $TotalSteps += 1 }
    if ($InstallVSCode) { $TotalSteps += 2 }  # VS Code + extensions
    if ($InstallAwsCli) { $TotalSteps += 1 }
    if ($InstallAzureCli) { $TotalSteps += 1 }
    $TotalSteps += 3 # Chocolatey, configs, health checks
    
    Initialize-Progress $TotalSteps
    
    # Install Chocolatey first
    Install-Chocolatey
    Update-Progress
    
    # Install development tools
    if ($InstallGit) {
        Install-Git
        Update-Progress
    }
    
    # Install containerization tools
    if ($InstallDocker) {
        Install-DockerDesktop
        Update-Progress
        Install-DockerCompose
        Update-Progress
    }
    
    # Install infrastructure tools
    if ($InstallK8s) {
        Install-Kubectl
        Update-Progress
        Install-Minikube
        Update-Progress
    }
    
    if ($InstallTerraform) {
        Install-Terraform
        Update-Progress
    }
    
    if ($InstallAnsible) {
        Install-Ansible
        Update-Progress
    }
    
    # Install cloud CLIs
    if ($InstallAwsCli) {
        Install-AWSCLI
        Update-Progress
    }
    
    if ($InstallAzureCli) {
        Install-AzureCLI
        Update-Progress
    }
    
    # Install development tools
    if ($InstallVSCode) {
        Install-VSCode
        Update-Progress
    }
    
    # Create configuration structure
    New-ConfigDirectories
    Update-Progress
    
    # Install VS Code extensions
    if ($InstallVSCode) {
        Install-VSCodeExtensions
        Update-Progress
    }
    
    # Run health checks
    if (-not $DryRun) {
        Test-HealthChecks
        Update-Progress
    }
    
    # Generate report
    if (-not $DryRun) {
        New-InstallationReport
        Update-Progress
    }
    
    Write-Host ""
    Write-Success "🎉 Installation completed successfully!"
    Write-Host ""
    
    if ($DryRun) {
        Write-Host "Dry run completed. No changes were made." -ForegroundColor $Magenta
        Write-Host "Run without -DryRun to perform the actual installation." -ForegroundColor $Yellow
    } else {
        Write-Host "Next steps:" -ForegroundColor $Magenta
        Write-Host "1. Restart your computer" -ForegroundColor $Cyan
        Write-Host "2. Start Docker Desktop" -ForegroundColor $Cyan
        Write-Host "3. Run verification script: .\verify.ps1" -ForegroundColor $Cyan
        Write-Host "4. Configure your tools: Check the configs\ directory" -ForegroundColor $Cyan
        Write-Host "5. Explore templates: Check the templates\ directory" -ForegroundColor $Cyan
        Write-Host "6. Check installation report: Get-Content ~\.devops-toolkit-install-report-*.txt" -ForegroundColor $Cyan
        Write-Host ""
        Write-Host "📚 Support Documentation Links:" -ForegroundColor $Cyan
        Write-Host "• Git: https://git-scm.com/doc" -ForegroundColor $Yellow
        Write-Host "• Docker: https://docs.docker.com/" -ForegroundColor $Yellow
        Write-Host "• Docker Compose: https://docs.docker.com/compose/" -ForegroundColor $Yellow
        Write-Host "• Kubernetes: https://kubernetes.io/docs/" -ForegroundColor $Yellow
        Write-Host "• Minikube: https://minikube.sigs.k8s.io/docs/" -ForegroundColor $Yellow
        Write-Host "• Terraform: https://developer.hashicorp.com/terraform/docs" -ForegroundColor $Yellow
        Write-Host "• Ansible: https://docs.ansible.com/" -ForegroundColor $Yellow
        Write-Host "• VS Code: https://code.visualstudio.com/docs" -ForegroundColor $Yellow
        Write-Host "• AWS CLI: https://docs.aws.amazon.com/cli/" -ForegroundColor $Yellow
        Write-Host "• Azure CLI: https://docs.microsoft.com/en-us/cli/azure/" -ForegroundColor $Yellow
        Write-Host ""
        Write-Host "Happy DevOps learning! 🚀" -ForegroundColor $Green
    }
    
    # Cleanup temporary files
    Remove-TempFiles
    
    Write-LogFile "INFO" "Installation completed successfully"
}

# Run main function
Main $args