# Monthly VM Backup Script - Full Shutdown Export with 7-Zip Compression
# Run Monthly on Saturday nights at 11pm
# Location: Hyper-V Server

param(
    [Parameter(ParameterSetName='SingleVM', Mandatory=$true)]
    [string]$VMName,
    
    [Parameter(ParameterSetName='AllVMs', Mandatory=$true)]
    [switch]$AllVMs,
    
    [Parameter(ParameterSetName='AllVMs')]
    [string[]]$ExcludeVMs = @(),
    
    [int]$MaxBackups = 3
)

# Configuration - Modify these paths as needed
$NASBackupPath = "\\nas5362\Backups"
$TempBackupPath = "F:\TempBackup"
$LocalBackupPath = "F:\Backups"
$SevenZipPath = "C:\Program Files\7-Zip\7z.exe"

# Configure logging
$LogPath = "C:\Scripts\Logs\Monthly_Backup_$(Get-Date -Format 'yyyyMM').log"
$null = New-Item -ItemType Directory -Path (Split-Path $LogPath -Parent) -Force -ErrorAction SilentlyContinue

function Write-Log {
    param([string]$Message, [string]$Level = "INFO")
    $TimeStamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $LogEntry = "[$TimeStamp] [$Level] $Message"
    Write-Host $LogEntry
    Add-Content -Path $LogPath -Value $LogEntry
}

function Test-NetworkPath {
    param([string]$Path)
    try {
        if (-not (Test-Path $Path -ErrorAction Stop)) {
            Write-Log "Network path does not exist: $Path" "ERROR"
            return $false
        }
        
        $TestFile = Join-Path $Path "test_write_$(Get-Date -Format 'yyyyMMddHHmmss').tmp"
        try {
            $null = New-Item -ItemType File -Path $TestFile -Force -ErrorAction Stop
            Remove-Item -Path $TestFile -Force -ErrorAction SilentlyContinue
            Write-Log "Network path is accessible and writable: $Path"
            return $true
        }
        catch {
            Write-Log "Network path exists but is not writable: $Path - $_" "ERROR"
            return $false
        }
    }
    catch {
        Write-Log "Network path test failed: $Path - $_" "ERROR"
        return $false
    }
}

function Test-Prerequisites {
    # Test 7-Zip installation
    if (-not (Test-Path $SevenZipPath)) {
        Write-Log "7-Zip not found at $SevenZipPath" "ERROR"
        Write-Log "Please install 7-Zip or update the SevenZipPath variable" "ERROR"
        return $false
    }
    
    # Test temp backup directory
    try {
        $null = New-Item -ItemType Directory -Path $TempBackupPath -Force -ErrorAction Stop
        Write-Log "Temp backup directory ready: $TempBackupPath"
    }
    catch {
        Write-Log "Cannot create temp backup directory: $TempBackupPath - $_" "ERROR"
        return $false
    }
    
    # Test local backup directory
    try {
        $null = New-Item -ItemType Directory -Path $LocalBackupPath -Force -ErrorAction Stop
        Write-Log "Local backup directory ready: $LocalBackupPath"
    }
    catch {
        Write-Log "Cannot create local backup directory: $LocalBackupPath - $_" "ERROR"
        return $false
    }
    
    # Test NAS connectivity (but don't fail if it's temporarily unavailable)
    if (-not (Test-NetworkPath $NASBackupPath)) {
        Write-Log "NAS connectivity test failed - will attempt copy later" "WARNING"
    }
    
    return $true
}

function Compress-BackupWithSevenZip {
    param(
        [string]$SourcePath,
        [string]$ArchivePath,
        [string]$VMName
    )
    
    try {
        Write-Log "Starting 7-Zip compression for $VMName..."
        Write-Log "Source: $SourcePath"
        Write-Log "Archive: $ArchivePath"
        
        # Ensure destination directory exists
        $ArchiveDir = Split-Path $ArchivePath -Parent
        $null = New-Item -ItemType Directory -Path $ArchiveDir -Force -ErrorAction SilentlyContinue
        
        # 7-Zip command: a = add, -t7z = 7z format, -mx=9 = maximum compression, -mmt = multithreaded
        $Arguments = @(
            'a',
            '-t7z',
            '-mx=9',
            '-mmt',
            "`"$ArchivePath`"",
            "`"$SourcePath\*`""
        )
        
        Write-Log "7-Zip command: `"$SevenZipPath`" $($Arguments -join ' ')"
        
        $StartTime = Get-Date
        $Process = Start-Process -FilePath $SevenZipPath -ArgumentList $Arguments -Wait -PassThru -NoNewWindow
        $EndTime = Get-Date
        
        $CompressionTime = ($EndTime - $StartTime).TotalMinutes
        Write-Log "7-Zip compression completed in $([math]::Round($CompressionTime, 1)) minutes"
        
        if ($Process.ExitCode -eq 0) {
            # Get compression statistics
            if (Test-Path $ArchivePath) {
                $OriginalSize = (Get-ChildItem -Path $SourcePath -Recurse -File | Measure-Object -Property Length -Sum).Sum
                $CompressedSize = (Get-Item $ArchivePath).Length
                $CompressionRatio = [math]::Round((1 - ($CompressedSize / $OriginalSize)) * 100, 1)
                
                $OriginalSizeGB = [math]::Round($OriginalSize / 1GB, 2)
                $CompressedSizeGB = [math]::Round($CompressedSize / 1GB, 2)
                
                Write-Log "Compression successful for $VMName"
                Write-Log "Original size: $OriginalSizeGB GB"
                Write-Log "Compressed size: $CompressedSizeGB GB"
                Write-Log "Compression ratio: $CompressionRatio%"
                return $true
            }
            else {
                Write-Log "7-Zip reported success but archive file not found" "ERROR"
                return $false
            }
        }
        else {
            Write-Log "7-Zip compression failed with exit code: $($Process.ExitCode)" "ERROR"
            return $false
        }
    }
    catch {
        Write-Log "Error during 7-Zip compression: $_" "ERROR"
        return $false
    }
}

function Move-ToLocalBackup {
    param(
        [string]$SourceFile,
        [string]$DestinationPath,
        [string]$VMName
    )
    
    try {
        Write-Log "Moving compressed backup to local backup folder for $VMName..."
        
        # Ensure destination directory exists
        $null = New-Item -ItemType Directory -Path $DestinationPath -Force -ErrorAction SilentlyContinue
        
        $DestinationFile = Join-Path $DestinationPath (Split-Path $SourceFile -Leaf)
        
        # Move the file (much faster than copy since it's on the same drive)
        Move-Item -Path $SourceFile -Destination $DestinationFile -Force
        Write-Log "Successfully moved backup to local folder for $VMName"
        
        return $DestinationFile
    }
    catch {
        Write-Log "Error moving to local backup folder: $_" "ERROR"
        return $null
    }
}

function Copy-AllBackupsToNAS {
    param(
        [string]$LocalPath,
        [string]$NASPath,
        [array]$BackupFiles
    )
    
    try {
        Write-Log "=== Starting bulk copy of all backups to NAS ==="
        Write-Log "Copying $($BackupFiles.Count) backup file(s) to NAS..."
        
        # Test NAS connectivity before attempting bulk copy
        if (-not (Test-NetworkPath $NASPath)) {
            throw "NAS is not accessible for bulk copy"
        }
        
        $SuccessfulCopies = 0
        $FailedCopies = 0
        $TotalSize = 0
        
        foreach ($BackupFile in $BackupFiles) {
            try {
                Write-Log "Copying: $(Split-Path $BackupFile -Leaf)"
                
                # Use robocopy for reliable network transfer
                $RobocopyArgs = @(
                    "`"$(Split-Path $BackupFile -Parent)`"",
                    "`"$NASPath`"",
                    "`"$(Split-Path $BackupFile -Leaf)`"",
                    "/Z",           # Copy files in restartable mode
                    "/R:3",         # Retry 3 times on failed copies
                    "/W:30",        # Wait 30 seconds between retries
                    "/TBD",         # Wait for share names to be defined
                    "/NP"           # No progress display
                )
                
                $StartTime = Get-Date
                $Process = Start-Process -FilePath "robocopy.exe" -ArgumentList $RobocopyArgs -Wait -PassThru -NoNewWindow
                $EndTime = Get-Date
                
                $CopyTime = ($EndTime - $StartTime).TotalSeconds
                
                # Robocopy exit codes: 0-3 are success
                if ($Process.ExitCode -le 3) {
                    $FileSize = (Get-Item $BackupFile).Length
                    $TotalSize += $FileSize
                    $FileSizeMB = [math]::Round($FileSize / 1MB, 1)
                    Write-Log "Successfully copied $(Split-Path $BackupFile -Leaf) ($FileSizeMB MB) in $CopyTime seconds"
                    $SuccessfulCopies++
                }
                else {
                    Write-Log "Failed to copy $(Split-Path $BackupFile -Leaf). Robocopy exit code: $($Process.ExitCode)" "ERROR"
                    $FailedCopies++
                }
            }
            catch {
                Write-Log "Error copying $(Split-Path $BackupFile -Leaf): $_" "ERROR"
                $FailedCopies++
            }
        }
        
        $TotalSizeGB = [math]::Round($TotalSize / 1GB, 2)
        Write-Log "=== Bulk copy completed ==="
        Write-Log "Successful copies: $SuccessfulCopies"
        Write-Log "Failed copies: $FailedCopies"
        Write-Log "Total data copied: $TotalSizeGB GB"
        
        return $FailedCopies -eq 0
    }
    catch {
        Write-Log "Error during bulk copy to NAS: $_" "ERROR"
        return $false
    }
}

function Cleanup-TempFiles {
    param(
        [string]$TempVMPath,
        [string]$TempArchive,
        [string]$VMName
    )
    
    try {
        Write-Log "Cleaning up temporary files for $VMName..."
        
        # Remove temp VM export folder
        if ($TempVMPath -and (Test-Path $TempVMPath)) {
            Remove-Item -Path $TempVMPath -Recurse -Force
            Write-Log "Removed temp VM folder: $TempVMPath"
        }
        
        # Remove temp archive
        if ($TempArchive -and (Test-Path $TempArchive)) {
            Remove-Item -Path $TempArchive -Force
            Write-Log "Removed temp archive: $TempArchive"
        }
    }
    catch {
        Write-Log "Warning: Could not cleanup some temp files for $VMName : $_" "WARNING"
    }
}

function Cleanup-OldBackups {
    param([string]$Path, [string]$Pattern, [int]$Keep)
    
    try {
        # Look for 7z archives instead of folders
        $BackupFiles = Get-ChildItem -Path $Path -File -Filter "*.7z" | 
                      Where-Object { $_.Name -match $Pattern } | 
                      Sort-Object CreationTime -Descending
        
        if ($BackupFiles.Count -gt $Keep) {
            $ToDelete = $BackupFiles | Select-Object -Skip $Keep
            foreach ($File in $ToDelete) {
                Write-Log "Deleting old backup: $($File.FullName)"
                Remove-Item -Path $File.FullName -Force
            }
        }
        $KeptCount = if ($BackupFiles.Count -lt $Keep) { $BackupFiles.Count } else { $Keep }
        Write-Log "Cleanup completed. Kept $KeptCount backups"
    }
    catch {
        Write-Log "Error during cleanup: $_" "ERROR"
        throw
    }
}

function Backup-SingleVM {
    param(
        [string]$VMName,
        [int]$MaxBackups
    )
    
    $VMBackupSuccess = $false
    $OriginalState = $null
    $TempVMFolder = $null
    $TempArchive = $null
    $LocalBackupFile = $null
    
    try {
        Write-Log "=== Starting backup for VM: $VMName ==="
        
        # Verify VM exists
        $VM = Get-VM -Name $VMName -ErrorAction Stop
        Write-Log "VM found: $($VM.Name) - State: $($VM.State)"
        
        # Create temp folders for this VM
        $VMTempFolder = Join-Path $TempBackupPath $VMName
        $TempVMFolder = Join-Path $VMTempFolder "Export"
        $TempArchive = Join-Path $VMTempFolder "Monthly_$($VMName)_$(Get-Date -Format 'yyyyMMdd_HHmm').7z"
        
        # Ensure temp directories exist
        $null = New-Item -ItemType Directory -Path $TempVMFolder -Force
        Write-Log "Created temp export folder: $TempVMFolder"
        
        # Store original VM state
        $OriginalState = $VM.State
        Write-Log "Original VM state: $OriginalState"
        
        # Shutdown VM if running
        if ($VM.State -eq 'Running') {
            Write-Log "Shutting down VM..."
            Stop-VM -Name $VMName -Force
            
            # Wait for shutdown with timeout
            $TimeoutSeconds = 300
            $Timer = 0
            do {
                Start-Sleep -Seconds 5
                $Timer += 5
                $VM = Get-VM -Name $VMName
            } while ($VM.State -ne 'Off' -and $Timer -lt $TimeoutSeconds)
            
            if ($VM.State -ne 'Off') {
                throw "VM failed to shutdown within $TimeoutSeconds seconds"
            }
            Write-Log "VM successfully shut down"
        }
        
        # Export VM to temp folder
        Write-Log "Starting VM export to temp folder..."
        $ExportJob = Export-VM -Name $VMName -Path $TempVMFolder -AsJob
        
        # Monitor export progress
        do {
            Start-Sleep -Seconds 30
            $Progress = Get-Job -Id $ExportJob.Id
            Write-Log "Export status: $($Progress.State)"
        } while ($Progress.State -eq 'Running')
        
        # Check export result
        $ExportResult = Receive-Job -Job $ExportJob
        Remove-Job -Job $ExportJob
        
        if ($Progress.State -eq 'Completed') {
            # Verify the export actually succeeded by checking for VM files
            $VMExportFolder = Get-ChildItem -Path $TempVMFolder -Directory -ErrorAction SilentlyContinue | Select-Object -First 1
            if ($VMExportFolder) {
                $VHDXFiles = Get-ChildItem -Path $VMExportFolder.FullName -Recurse -Filter "*.vhdx" -ErrorAction SilentlyContinue
                $VMCXFiles = Get-ChildItem -Path $VMExportFolder.FullName -Recurse -Filter "*.vmcx" -ErrorAction SilentlyContinue
                
                if ($VHDXFiles.Count -eq 0 -and $VMCXFiles.Count -eq 0) {
                    throw "Export job completed but no VM files were found in temp folder"
                }
                
                Write-Log "VM export to temp folder completed successfully"
                Write-Log "Found $($VHDXFiles.Count) VHDX file(s) and $($VMCXFiles.Count) VMCX file(s)"
            } else {
                throw "Export job completed but no VM folder was created in temp directory"
            }
        }
        else {
            throw "VM export failed with job state: $($Progress.State)"
        }
        
        # Restart VM if it was originally running
        if ($OriginalState -eq 'Running') {
            Write-Log "Restarting VM..."
            Start-VM -Name $VMName
            Write-Log "VM restarted successfully"
        }
        
        # Compress the backup with 7-Zip
        if (-not (Compress-BackupWithSevenZip -SourcePath $TempVMFolder -ArchivePath $TempArchive -VMName $VMName)) {
            throw "7-Zip compression failed"
        }
        
        # Move compressed backup to local backup folder
        $LocalBackupFile = Move-ToLocalBackup -SourceFile $TempArchive -DestinationPath $LocalBackupPath -VMName $VMName
        if (-not $LocalBackupFile) {
            throw "Failed to move backup to local backup folder"
        }
        
        # Immediately cleanup temp files for this VM after successful compression and move
        Write-Log "Cleaning up temp files for $VMName after successful compression..."
        Cleanup-TempFiles -TempVMPath $TempVMFolder -TempArchive $TempArchive -VMName $VMName
        
        $VMBackupSuccess = $true
        Write-Log "=== Monthly backup completed successfully for $VMName ===" "SUCCESS"
        
    }
    catch {
        Write-Log "=== Backup failed for $VMName : $_ ===" "ERROR"
        
        # Attempt to restart VM if it was originally running
        if ($OriginalState -eq 'Running') {
            try {
                $CurrentVM = Get-VM -Name $VMName -ErrorAction SilentlyContinue
                if ($CurrentVM -and $CurrentVM.State -eq 'Off') {
                    Write-Log "Attempting to restart VM after failure..."
                    Start-VM -Name $VMName
                    Write-Log "VM restarted after failure"
                }
            }
            catch {
                Write-Log "Failed to restart VM after backup failure: $_" "ERROR"
            }
        }
    }
    finally {
        # Always cleanup temp files for this VM (backup in case not already done)
        if ((Test-Path $TempVMFolder -ErrorAction SilentlyContinue) -or (Test-Path $TempArchive -ErrorAction SilentlyContinue)) {
            Write-Log "Final cleanup of any remaining temp files for $VMName..."
            Cleanup-TempFiles -TempVMPath $TempVMFolder -TempArchive $TempArchive -VMName $VMName
        }
    }
    
    # Return both success status and local backup file path
    return @{
        Success = $VMBackupSuccess
        BackupFile = $LocalBackupFile
    }
}

# Main execution
try {
    Write-Log "Starting monthly backup process"
    
    # Test prerequisites
    if (-not (Test-Prerequisites)) {
        throw "Prerequisites check failed"
    }
    
    # Determine which VMs to backup
    $VMsToBackup = @()
    
    if ($AllVMs) {
        Write-Log "Backing up all VMs (excluding specified VMs)"
        $AllVirtualMachines = Get-VM | Where-Object { $_.Name -notin $ExcludeVMs }
        $VMsToBackup = $AllVirtualMachines.Name
        
        if ($ExcludeVMs.Count -gt 0) {
            Write-Log "Excluded VMs: $($ExcludeVMs -join ', ')"
        }
        Write-Log "VMs to backup: $($VMsToBackup -join ', ')"
    }
    else {
        $VMsToBackup = @($VMName)
        Write-Log "Backing up single VM: $VMName"
    }
    
    if ($VMsToBackup.Count -eq 0) {
        throw "No VMs found to backup"
    }
    
    # Backup each VM
    $SuccessCount = 0
    $FailureCount = 0
    $Results = @()
    $SuccessfulBackupFiles = @()
    
    foreach ($VM in $VMsToBackup) {
        $StartTime = Get-Date
        $BackupResult = Backup-SingleVM -VMName $VM -MaxBackups $MaxBackups
        $EndTime = Get-Date
        $Duration = ($EndTime - $StartTime).TotalMinutes
        
        $Results += [PSCustomObject]@{
            VMName = $VM
            Success = $BackupResult.Success
            Duration = [math]::Round($Duration, 1)
            BackupFile = $BackupResult.BackupFile
        }
        
        if ($BackupResult.Success) {
            $SuccessCount++
            if ($BackupResult.BackupFile) {
                $SuccessfulBackupFiles += $BackupResult.BackupFile
            }
        } else {
            $FailureCount++
        }
    }
    
    # Copy all successful backups to NAS in one batch
    $NASCopySuccess = $false
    if ($SuccessfulBackupFiles.Count -gt 0) {
        Write-Log "All VM backups completed. Starting bulk copy to NAS..."
        $NASCopySuccess = Copy-AllBackupsToNAS -LocalPath $LocalBackupPath -NASPath $NASBackupPath -BackupFiles $SuccessfulBackupFiles
        
        if ($NASCopySuccess) {
            Write-Log "Successfully copied all backups to NAS"
            
            # Now cleanup old backups on NAS for each VM
            Write-Log "Cleaning up old backups on NAS..."
            foreach ($VM in $VMsToBackup) {
                try {
                    Cleanup-OldBackups -Path $NASBackupPath -Pattern "^Monthly_$($VM)_\d{8}_\d{4}\.7z$" -Keep $MaxBackups
                }
                catch {
                    Write-Log "Warning: Could not cleanup old backups for $VM on NAS: $_" "WARNING"
                }
            }
        }
        else {
            Write-Log "Failed to copy some or all backups to NAS" "ERROR"
        }
    }
    
    # Cleanup old local backups regardless of NAS copy success
    Write-Log "Cleaning up old local backups..."
    foreach ($VM in $VMsToBackup) {
        try {
            Cleanup-OldBackups -Path $LocalBackupPath -Pattern "^Monthly_$($VM)_\d{8}_\d{4}\.7z$" -Keep $MaxBackups
        }
        catch {
            Write-Log "Warning: Could not cleanup old local backups for $VM : $_" "WARNING"
        }
    }
    
    # Final summary
    Write-Log "=== BACKUP SUMMARY ==="
    Write-Log "Total VMs processed: $($VMsToBackup.Count)"
    Write-Log "Successful backups: $SuccessCount"
    Write-Log "Failed backups: $FailureCount"
    Write-Log "NAS copy success: $(if ($NASCopySuccess) { 'YES' } else { 'NO' })"
    
    foreach ($Result in $Results) {
        $Status = if ($Result.Success) { "SUCCESS" } else { "FAILED" }
        Write-Log "$($Result.VMName): $Status ($($Result.Duration) minutes)"
    }
    
    # Display local backup status
    Write-Log "=== LOCAL BACKUP STATUS ==="
    if (Test-Path $LocalBackupPath) {
        $LocalBackups = Get-ChildItem -Path $LocalBackupPath -File -Filter "*.7z" | Sort-Object CreationTime -Descending
        $TotalLocalSize = 0
        
        foreach ($Backup in $LocalBackups) {
            $Size = $Backup.Length
            $SizeGB = [math]::Round($Size / 1GB, 2)
            $TotalLocalSize += $Size
            Write-Log "$($Backup.Name): $SizeGB GB (Created: $(Get-Date $Backup.CreationTime -Format 'yyyy-MM-dd HH:mm'))"
        }
        
        $TotalLocalSizeGB = [math]::Round($TotalLocalSize / 1GB, 2)
        Write-Log "Total local backup storage used: $TotalLocalSizeGB GB"
    }
    
    if ($FailureCount -gt 0) {
        Write-Log "Monthly backup process completed with $FailureCount failure(s)" "WARNING"
        exit 1
    } elseif (-not $NASCopySuccess -and $SuccessfulBackupFiles.Count -gt 0) {
        Write-Log "Monthly backup process completed but NAS copy failed - backups available locally" "WARNING"
        exit 1
    } else {
        Write-Log "Monthly backup process completed successfully" "SUCCESS"
    }
}
catch {
    Write-Log "Monthly backup process failed: $_" "ERROR"
    exit 1
}

# Example usage:
# Single VM:
# .\Monthly-VMBackup.ps1 -VMName "MyVM" -MaxBackups 3
# All VMs:
# .\Monthly-VMBackup.ps1 -AllVMs -MaxBackups 3
# All VMs except specific ones:
# .\Monthly-VMBackup.ps1 -AllVMs -ExcludeVMs @("TestVM", "TempVM") -MaxBackups 3

# New workflow:
# 1. Export VM to F:\TempBackup\{VMName}\Export\
# 2. Compress with 7-Zip to F:\TempBackup\{VMName}\{Archive}.7z
# 3. Move compressed archive to F:\Backups\{Archive}.7z
# 4. Clean up temp files for this VM
# 5. Repeat for all VMs
# 6. Once ALL VMs are done, bulk copy F:\Backups\*.7z to NAS
# 7. Clean up old backups on both local F: drive and NAS