HyperV-Inventory.ps1

#Requires -Version 5.1
<#
.SYNOPSIS
    HyperV-Inventory.ps1 - Hyper-V environment inventory tool (RVTools equivalent)

.DESCRIPTION
    Collects comprehensive Hyper-V environment details across one or more hosts
    and exports to:
      * A colour-coded Excel workbook with a dashboard summary tab (requires ImportExcel)
      * A self-contained HTML report with sortable/filterable tables
      * Individual CSV files as a fallback

    Tabs / sections collected:
      Dashboard    - At-a-glance summary with key metrics and charts
      vInfo        - Virtual machine inventory (state, CPU, memory, uptime)
      vDisk        - Virtual hard disks (path, size, type, controller)
      vNetwork     - VM network adapters (switch, MAC, VLAN, IP)
      vSnapshot    - Checkpoints / snapshots
      vHost        - Hyper-V host details (CPU, memory, version)
      vSwitch      - Virtual switches
      vReplication - VM replication status
      vIntegration - Integration services per VM

.PARAMETER ComputerName
    One or more Hyper-V host names. Defaults to localhost.

.PARAMETER OutputPath
    Directory for output files. Defaults to the script directory.

.PARAMETER OutputFormat
    'Excel' (default, requires ImportExcel), 'HTML', 'CSV', or 'All'.

.PARAMETER Credential
    PSCredential for remote hosts. Omit for current user / localhost.

.EXAMPLE
    .\HyperV-Inventory.ps1

.EXAMPLE
    .\HyperV-Inventory.ps1 -ComputerName HV01,HV02,HV03

.EXAMPLE
    .\HyperV-Inventory.ps1 -OutputFormat All -OutputPath C:\Reports

.NOTES
    Requires Hyper-V PowerShell module (RSAT-Hyper-V-Tools or the Hyper-V role).
    Run as Administrator for full detail (especially memory/CPU counters).
#>

[CmdletBinding()]
param(
    [string[]] $ComputerName = @($env:COMPUTERNAME),
    [string]   $OutputPath   = $PSScriptRoot,
    [ValidateSet('Excel','HTML','CSV','All')]
    [string]   $OutputFormat  = 'All',
    [PSCredential] $Credential
)

Set-StrictMode -Version Latest
$ErrorActionPreference = 'Continue'

#region -- Helpers --------------------------------------------------------------

function Write-Section ($msg) {
    Write-Host "`n$('-' * 60)" -ForegroundColor Cyan
    Write-Host "  $msg" -ForegroundColor Cyan
    Write-Host $('-' * 60) -ForegroundColor Cyan
}

function Format-GB ($bytes) {
    if ($null -eq $bytes -or $bytes -eq 0) { return '0 GB' }
    '{0:N2} GB' -f ($bytes / 1GB)
}

function Format-GBRaw ($bytes) {
    if ($null -eq $bytes -or $bytes -eq 0) { return 0 }
    [math]::Round($bytes / 1GB, 2)
}

function Format-Uptime ($ts) {
    if ($null -eq $ts) { return 'N/A' }
    '{0}d {1:D2}h {2:D2}m' -f $ts.Days, $ts.Hours, $ts.Minutes
}

function Get-RemoteParams ($hvHost) {
    $p = @{ ComputerName = $hvHost; ErrorAction = 'SilentlyContinue' }
    if ($Credential -and $hvHost -ne $env:COMPUTERNAME) { $p['Credential'] = $Credential }
    $p
}

function Escape-Html ($str) {
    if ($null -eq $str) { return '' }
    [System.Web.HttpUtility]::HtmlEncode($str.ToString())
}

# Safely retrieve a property that may not exist on all object types
function Get-Prop ($obj, $prop) {
    if ($null -eq $obj) { return $null }
    if ($obj.PSObject.Properties[$prop]) { return $obj.$prop }
    return $null
}

#endregion

#region -- Dependency checks ----------------------------------------------------

Write-Section 'Checking dependencies'

if (-not (Get-Module -ListAvailable Hyper-V)) {
    Write-Error 'Hyper-V PowerShell module not found. Install RSAT-Hyper-V-Tools or the Hyper-V role.'
    exit 1
}
Import-Module Hyper-V -ErrorAction Stop

$useExcel = $false
$wantExcel = $OutputFormat -in 'Excel','All'
if ($wantExcel) {
    if (Get-Module -ListAvailable ImportExcel) {
        Import-Module ImportExcel -ErrorAction SilentlyContinue
        $useExcel = $true
        Write-Host '  ImportExcel found - Excel output enabled' -ForegroundColor Green
    } else {
        Write-Warning 'ImportExcel not found. Excel output skipped.'
        Write-Warning 'Install with: Install-Module ImportExcel -Scope CurrentUser'
    }
}

$useHtml = $OutputFormat -in 'HTML','All'
$useCsv  = $OutputFormat -in 'CSV','All' -or (-not $useExcel -and -not $useHtml)

if (-not (Test-Path $OutputPath)) { New-Item -ItemType Directory -Path $OutputPath | Out-Null }
$timestamp = Get-Date -Format 'yyyyMMdd_HHmmss'
$excelFile = Join-Path $OutputPath "HyperV-Inventory_$timestamp.xlsx"
$htmlFile  = Join-Path $OutputPath "HyperV-Inventory_$timestamp.html"
$csvBase   = Join-Path $OutputPath "HyperV-Inventory_$timestamp"

#endregion

#region -- Data collection ------------------------------------------------------

$allVInfo        = [System.Collections.Generic.List[PSObject]]::new()
$allVDisk        = [System.Collections.Generic.List[PSObject]]::new()
$allVNetwork     = [System.Collections.Generic.List[PSObject]]::new()
$allVSnapshot    = [System.Collections.Generic.List[PSObject]]::new()
$allVHost        = [System.Collections.Generic.List[PSObject]]::new()
$allVSwitch      = [System.Collections.Generic.List[PSObject]]::new()
$allVReplication = [System.Collections.Generic.List[PSObject]]::new()
$allVIntegration = [System.Collections.Generic.List[PSObject]]::new()

foreach ($hvHost in $ComputerName) {

    Write-Section "Collecting from host: $hvHost"
    $rp = Get-RemoteParams $hvHost

    #-- Host info ----------------------------------------------------------------
    Write-Host '  [Host] Gathering host details...' -ForegroundColor Yellow
    try {
        $hostInfo = Get-VMHost @rp
        $ciParams = @{ ErrorAction = 'SilentlyContinue' }
        if ($Credential -and $hvHost -ne $env:COMPUTERNAME) { $ciParams['Credential'] = $Credential }

        $os  = Get-CimInstance Win32_OperatingSystem -ComputerName $hvHost @ciParams
        $cpu = Get-CimInstance Win32_Processor       -ComputerName $hvHost @ciParams
        $sys = Get-CimInstance Win32_ComputerSystem  -ComputerName $hvHost @ciParams

        $allVHost.Add([PSCustomObject]@{
            Host                  = $hvHost
            'Manufacturer'        = $sys.Manufacturer
            'Model'               = $sys.Model
            'OS'                  = $os.Caption
            'OS Build'            = $os.BuildNumber
            'Hyper-V Version'     = (Get-Item 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion' -ErrorAction SilentlyContinue).GetValue('CurrentBuildNumber')
            'CPU Sockets'         = ($cpu | Measure-Object).Count
            'CPU Logical Procs'   = ($cpu | Measure-Object NumberOfLogicalProcessors -Sum).Sum
            'CPU Name'            = ($cpu | Select-Object -First 1).Name
            'Total RAM'           = Format-GB $sys.TotalPhysicalMemory
            'Free RAM'            = Format-GB ($os.FreePhysicalMemory * 1KB)
            'VM Default Path'     = $hostInfo.VirtualMachinePath
            'VHD Default Path'    = $hostInfo.VirtualHardDiskPath
            'Live Migration'      = $hostInfo.VirtualMachineMigrationEnabled
            'Max Live Migrations' = $hostInfo.MaximumVirtualMachineMigrations
            'NUMA Spanning'       = $hostInfo.NumaSpanningEnabled
            'Enhanced Session'    = $hostInfo.EnableEnhancedSessionMode
            'Uptime'              = Format-Uptime ($os.LocalDateTime - $os.LastBootUpTime)
        })
    }
    catch { Write-Warning "  Could not collect host info from $hvHost`: $_" }

    #-- Virtual switches ---------------------------------------------------------
    Write-Host '  [vSwitch] Gathering virtual switches...' -ForegroundColor Yellow
    try {
        foreach ($sw in (Get-VMSwitch @rp)) {
            $allVSwitch.Add([PSCustomObject]@{
                Host               = $hvHost
                'Switch Name'      = $sw.Name
                'Switch Type'      = $sw.SwitchType
                'Net Adapter Name' = $sw.NetAdapterInterfaceDescription
                'Notes'            = $sw.Notes
                'Allow Mgmt OS'    = $sw.AllowManagementOS
                'Bandwidth Mode'   = $sw.BandwidthReservationMode
                'Extensions'       = if (Get-Prop $sw 'Extensions') { ($sw.Extensions | ForEach-Object { $_.Name }) -join ', ' } else { '' }
            })
        }
    }
    catch { Write-Warning "  Could not collect vSwitch from $hvHost`: $_" }

    #-- VMs ----------------------------------------------------------------------
    Write-Host '  [VM] Gathering virtual machines...' -ForegroundColor Yellow
    $vms = @()
    try { $vms = @(Get-VM @rp) }
    catch { Write-Warning "  Could not list VMs on $hvHost`: $_"; continue }
    Write-Host "      Found $($vms.Count) VM(s)" -ForegroundColor Gray

    foreach ($vm in $vms) {

        #-- vInfo ----------------------------------------------------------------
        $guestOS   = try { (Get-VMIntegrationService -VMName $vm.Name -ComputerName $hvHost -ErrorAction SilentlyContinue |
                            Where-Object Name -eq 'Operating System Shutdown').PrimaryStatusDescription } catch { 'N/A' }
        $memDemand = try { $vm.MemoryDemand } catch { $null }

        $allVInfo.Add([PSCustomObject]@{
            Host                    = $hvHost
            'VM Name'               = $vm.Name
            'State'                 = $vm.State
            'Status'                = $vm.Status
            'Generation'            = $vm.Generation
            'vCPU Count'            = $vm.ProcessorCount
            'CPU Usage (%)'         = $vm.CPUUsage
            'Assigned RAM (GB)'     = Format-GBRaw $vm.MemoryAssigned
            'Startup RAM (GB)'      = Format-GBRaw $vm.MemoryStartup
            'Minimum RAM (GB)'      = Format-GBRaw $vm.MemoryMinimum
            'Maximum RAM (GB)'      = Format-GBRaw $vm.MemoryMaximum
            'Dynamic Memory'        = $vm.DynamicMemoryEnabled
            'Memory Demand (GB)'    = Format-GBRaw $memDemand
            'Uptime'                = Format-Uptime $vm.Uptime
            'Integration Tools Ver' = $vm.IntegrationServicesVersion
            'Guest OS'              = $guestOS
            'Notes'                 = $vm.Notes
            'Path'                  = $vm.Path
            'Config File'           = $vm.ConfigurationLocation
            'Checkpoint Type'       = $vm.CheckpointType
            'Auto Start Action'     = $vm.AutomaticStartAction
            'Auto Stop Action'      = $vm.AutomaticStopAction
            'Auto Start Delay (s)'  = $vm.AutomaticStartDelay
            'VM ID'                 = $vm.Id
            'Created'               = $vm.CreationTime
        })

        #-- vDisk ----------------------------------------------------------------
        try {
            $disks = Get-VMHardDiskDrive -VMName $vm.Name -ComputerName $hvHost -ErrorAction SilentlyContinue
            foreach ($disk in $disks) {
                $vhdInfo = $null
                if ($disk.Path) {
                    try { $vhdInfo = Get-VHD -Path $disk.Path -ComputerName $hvHost -ErrorAction SilentlyContinue } catch {}
                }
                $allVDisk.Add([PSCustomObject]@{
                    Host               = $hvHost
                    'VM Name'          = $vm.Name
                    'Controller Type'  = $disk.ControllerType
                    'Controller #'     = $disk.ControllerNumber
                    'Controller Loc'   = $disk.ControllerLocation
                    'Disk Path'        = $disk.Path
                    'VHD Type'         = Get-Prop $vhdInfo 'VhdType'
                    'VHD Format'       = Get-Prop $vhdInfo 'VhdFormat'
                    'File Size (GB)'   = Format-GBRaw (Get-Prop $vhdInfo 'FileSize')
                    'Current Size (GB)'= Format-GBRaw (Get-Prop $vhdInfo 'Size')
                    'Max Size (GB)'    = Format-GBRaw (Get-Prop $vhdInfo 'MinimumSize')
                    'Fragmentation %'  = Get-Prop $vhdInfo 'FragmentationPercentage'
                    'Block Size'       = Get-Prop $vhdInfo 'BlockSize'
                    'Logical Sector'   = Get-Prop $vhdInfo 'LogicalSectorSize'
                    'Physical Sector'  = Get-Prop $vhdInfo 'PhysicalSectorSize'
                    'Attached'         = Get-Prop $vhdInfo 'Attached'
                    'Parent Path'      = Get-Prop $vhdInfo 'ParentPath'
                })
            }
        }
        catch { Write-Warning "  Could not get disks for $($vm.Name): $_" }

        #-- vNetwork -------------------------------------------------------------
        try {
            $nics = Get-VMNetworkAdapter -VMName $vm.Name -ComputerName $hvHost -ErrorAction SilentlyContinue
            foreach ($nic in $nics) {
                $vlan = try { Get-VMNetworkAdapterVlan -VMNetworkAdapter $nic -ErrorAction SilentlyContinue } catch { $null }
                $allVNetwork.Add([PSCustomObject]@{
                    Host             = $hvHost
                    'VM Name'        = $vm.Name
                    'Adapter Name'   = $nic.Name
                    'Switch Name'    = Get-Prop $nic 'SwitchName'
                    'MAC Address'    = Get-Prop $nic 'MacAddress'
                    'Dynamic MAC'    = Get-Prop $nic 'DynamicMacAddressEnabled'
                    'IP Addresses'   = if (Get-Prop $nic 'IPAddresses') { ($nic.IPAddresses -join ', ') } else { '' }
                    'VLAN ID'        = Get-Prop $vlan 'AccessVlanId'
                    'VLAN Mode'      = Get-Prop $vlan 'OperationMode'
                    'Status'         = if (Get-Prop $nic 'Status') { ($nic.Status -join ', ') } else { '' }
                    'Connected'      = Get-Prop $nic 'Connected'
                    'BW Min (Mbps)'  = if (Get-Prop $nic 'BandwidthSetting') { Get-Prop $nic.BandwidthSetting 'MinimumBandwidthAbsolute' } else { $null }
                    'BW Max (Mbps)'  = if (Get-Prop $nic 'BandwidthSetting') { Get-Prop $nic.BandwidthSetting 'MaximumBandwidth' } else { $null }
                    'Device ID'      = Get-Prop $nic 'DeviceId'
                })
            }
        }
        catch { Write-Warning "  Could not get NICs for $($vm.Name): $_" }

        #-- vSnapshot ------------------------------------------------------------
        try {
            foreach ($snap in (Get-VMSnapshot -VMName $vm.Name -ComputerName $hvHost -ErrorAction SilentlyContinue)) {
                $allVSnapshot.Add([PSCustomObject]@{
                    Host             = $hvHost
                    'VM Name'        = $vm.Name
                    'Snapshot Name'  = $snap.Name
                    'Snapshot Type'  = Get-Prop $snap 'SnapshotType'
                    'Created'        = Get-Prop $snap 'CreationTime'
                    'Parent'         = Get-Prop $snap 'ParentSnapshotName'
                    'Notes'          = Get-Prop $snap 'Notes'
                    'vCPU Count'     = Get-Prop $snap 'ProcessorCount'
                    'Assigned RAM'   = Format-GB (Get-Prop $snap 'MemoryAssigned')
                    'ID'             = Get-Prop $snap 'Id'
                })
            }
        }
        catch { Write-Warning "  Could not get snapshots for $($vm.Name): $_" }

        #-- vReplication ---------------------------------------------------------
        try {
            $rep = Get-VMReplication -VMName $vm.Name -ComputerName $hvHost -ErrorAction SilentlyContinue
            foreach ($r in $rep) {
                $allVReplication.Add([PSCustomObject]@{
                    Host                    = $hvHost
                    'VM Name'               = $vm.Name
                    'Replication State'     = Get-Prop $r 'State'
                    'Replication Health'    = Get-Prop $r 'Health'
                    'Replication Mode'      = Get-Prop $r 'Mode'
                    'Replica Server'        = Get-Prop $r 'ReplicaServerName'
                    'Primary Server'        = Get-Prop $r 'PrimaryServerName'
                    'Auth Type'             = Get-Prop $r 'AuthenticationType'
                    'Compression'           = Get-Prop $r 'CompressionEnabled'
                    'Last Replication Time' = Get-Prop $r 'LastReplicationTime'
                    'Replication Freq (s)'  = Get-Prop $r 'ReplicationFrequencySec'
                    'Recovery Points'       = Get-Prop $r 'RecoveryHistory'
                    'VSS Snapshot (hrs)'    = Get-Prop $r 'VSSSnapshotFrequencyHour'
                })
            }
        }
        catch { }

        #-- vIntegration ---------------------------------------------------------
        try {
            foreach ($svc in (Get-VMIntegrationService -VMName $vm.Name -ComputerName $hvHost -ErrorAction SilentlyContinue)) {
                $allVIntegration.Add([PSCustomObject]@{
                    Host               = $hvHost
                    'VM Name'          = $vm.Name
                    'Service Name'     = $svc.Name
                    'Enabled'          = Get-Prop $svc 'Enabled'
                    'Primary Status'   = Get-Prop $svc 'PrimaryStatusDescription'
                    'Secondary Status' = Get-Prop $svc 'SecondaryStatusDescription'
                    'Interface Name'   = Get-Prop $svc 'InterfaceComponentName'
                })
            }
        }
        catch { Write-Warning "  Could not get integration services for $($vm.Name): $_" }

    } # end foreach VM
} # end foreach host

#endregion

#region -- Summary metrics ------------------------------------------------------

$totalVMs      = $allVInfo.Count
$runningVMs    = @($allVInfo | Where-Object { $_.'State' -eq 'Running' }).Count
$offVMs        = @($allVInfo | Where-Object { $_.'State' -eq 'Off' }).Count
$savedVMs      = @($allVInfo | Where-Object { $_.'State' -notin 'Running','Off' }).Count
$totalvCPU     = ($allVInfo | Measure-Object 'vCPU Count' -Sum).Sum
$totalRAM      = ($allVInfo | Measure-Object 'Assigned RAM (GB)' -Sum).Sum
$totalDiskGB   = ($allVDisk | Measure-Object 'File Size (GB)' -Sum).Sum
$totalDisks    = $allVDisk.Count
$totalSnaps    = $allVSnapshot.Count
$totalNICs     = $allVNetwork.Count
$totalSwitches = $allVSwitch.Count
$totalReplVMs  = $allVReplication.Count

$generatedAt = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'

#endregion

#region -- Excel output ---------------------------------------------------------

if ($useExcel) {
    Write-Section 'Writing Excel report'
    if (Test-Path $excelFile) { Remove-Item $excelFile }

    #-- Colour helpers -----------------------------------------------------------
    $clrGreen      = [System.Drawing.Color]::FromArgb(198,239,206)   # light green fill
    $clrGreenFont  = [System.Drawing.Color]::FromArgb(0,97,0)
    $clrRed        = [System.Drawing.Color]::FromArgb(255,199,206)   # light red fill
    $clrRedFont    = [System.Drawing.Color]::FromArgb(156,0,6)
    $clrAmber      = [System.Drawing.Color]::FromArgb(255,235,156)   # amber fill
    $clrAmberFont  = [System.Drawing.Color]::FromArgb(156,101,0)
    $clrBlue       = [System.Drawing.Color]::FromArgb(189,215,238)
    $clrBlueFont   = [System.Drawing.Color]::FromArgb(31,73,125)
    $clrHeader     = [System.Drawing.Color]::FromArgb(31,73,125)     # dark blue header
    $clrHeaderFont = [System.Drawing.Color]::White

    #-- Dashboard sheet ----------------------------------------------------------
    Write-Host '  Writing: Dashboard' -ForegroundColor Green

    $dashData = [ordered]@{
        'Generated'              = $generatedAt
        'Hosts Inventoried'      = $ComputerName.Count
        ''                       = ''
        'Total VMs'              = $totalVMs
        'Running VMs'            = $runningVMs
        'Off VMs'                = $offVMs
        'Other State VMs'        = $savedVMs
        ' '                      = ''
        'Total vCPUs'            = $totalvCPU
        'Total Assigned RAM (GB)'= [math]::Round($totalRAM,2)
        'Total Disk Used (GB)'   = [math]::Round($totalDiskGB,2)
        '  '                     = ''
        'Total vDisks'           = $totalDisks
        'Total vNICs'            = $totalNICs
        'Total Snapshots'        = $totalSnaps
        'Virtual Switches'       = $totalSwitches
        'Replicated VMs'         = $totalReplVMs
    }

    $dashRows = $dashData.GetEnumerator() | ForEach-Object {
        [PSCustomObject]@{ Metric = $_.Key; Value = $_.Value }
    }

    $dashRows | Export-Excel -Path $excelFile -WorksheetName 'Dashboard' -MoveToStart `
        -AutoSize -FreezeTopRow -BoldTopRow -TableStyle Medium2

    # Style the dashboard
    $pkg = Open-ExcelPackage -Path $excelFile
    $ws  = $pkg.Workbook.Worksheets['Dashboard']

    # Bold the metric column, highlight key rows
    $rowMap = @{ 'Running VMs' = $clrGreen; 'Off VMs' = $clrRed; 'Other State VMs' = $clrAmber }
    for ($r = 2; $r -le ($dashRows.Count + 1); $r++) {
        $metric = $ws.Cells[$r,1].Value
        if ($rowMap.ContainsKey($metric)) {
            $ws.Cells[$r,1].Style.Fill.PatternType = [OfficeOpenXml.Style.ExcelFillStyle]::Solid
            $ws.Cells[$r,2].Style.Fill.PatternType = [OfficeOpenXml.Style.ExcelFillStyle]::Solid
            $ws.Cells[$r,1].Style.Fill.BackgroundColor.SetColor($rowMap[$metric])
            $ws.Cells[$r,2].Style.Fill.BackgroundColor.SetColor($rowMap[$metric])
        }
    }
    Close-ExcelPackage $pkg

    #-- vInfo sheet --------------------------------------------------------------
    if ($allVInfo.Count -gt 0) {
        Write-Host "  Writing: vInfo ($($allVInfo.Count) rows)" -ForegroundColor Green
        $allVInfo | Export-Excel -Path $excelFile -WorksheetName 'vInfo' `
            -AutoSize -AutoFilter -FreezeTopRow -BoldTopRow -TableStyle Medium2

        $pkg = Open-ExcelPackage -Path $excelFile
        $ws  = $pkg.Workbook.Worksheets['vInfo']

        # Find the State column index
        $stateCol = $null
        for ($c = 1; $c -le $ws.Dimension.End.Column; $c++) {
            if ($ws.Cells[1,$c].Value -eq 'State') { $stateCol = $c; break }
        }

        if ($stateCol) {
            for ($r = 2; $r -le $ws.Dimension.End.Row; $r++) {
                $state = $ws.Cells[$r,$stateCol].Value
                $fill  = switch ($state) {
                    'Running' { $clrGreen }
                    'Off'     { $clrRed }
                    default   { $clrAmber }
                }
                $font  = switch ($state) {
                    'Running' { $clrGreenFont }
                    'Off'     { $clrRedFont }
                    default   { $clrAmberFont }
                }
                $ws.Cells[$r,$stateCol].Style.Fill.PatternType = [OfficeOpenXml.Style.ExcelFillStyle]::Solid
                $ws.Cells[$r,$stateCol].Style.Fill.BackgroundColor.SetColor($fill)
                $ws.Cells[$r,$stateCol].Style.Font.Color.SetColor($font)
                $ws.Cells[$r,$stateCol].Style.Font.Bold = $true
            }
        }
        Close-ExcelPackage $pkg
    }

    #-- vDisk sheet --------------------------------------------------------------
    if ($allVDisk.Count -gt 0) {
        Write-Host "  Writing: vDisk ($($allVDisk.Count) rows)" -ForegroundColor Green
        $allVDisk | Export-Excel -Path $excelFile -WorksheetName 'vDisk' `
            -AutoSize -AutoFilter -FreezeTopRow -BoldTopRow -TableStyle Medium2

        $pkg = Open-ExcelPackage -Path $excelFile
        $ws  = $pkg.Workbook.Worksheets['vDisk']

        # Colour-code disk sizes: >500GB=red, 100-500GB=amber, <100GB=green
        $sizeCol = $null
        for ($c = 1; $c -le $ws.Dimension.End.Column; $c++) {
            if ($ws.Cells[1,$c].Value -eq 'File Size (GB)') { $sizeCol = $c; break }
        }

        if ($sizeCol) {
            for ($r = 2; $r -le $ws.Dimension.End.Row; $r++) {
                $sz   = [double]($ws.Cells[$r,$sizeCol].Value)
                $fill = if ($sz -ge 500) { $clrRed } elseif ($sz -ge 100) { $clrAmber } else { $clrGreen }
                $ws.Cells[$r,$sizeCol].Style.Fill.PatternType = [OfficeOpenXml.Style.ExcelFillStyle]::Solid
                $ws.Cells[$r,$sizeCol].Style.Fill.BackgroundColor.SetColor($fill)
            }
        }

        # Colour Dynamic vs Fixed
        $typeCol = $null
        for ($c = 1; $c -le $ws.Dimension.End.Column; $c++) {
            if ($ws.Cells[1,$c].Value -eq 'VHD Type') { $typeCol = $c; break }
        }
        if ($typeCol) {
            for ($r = 2; $r -le $ws.Dimension.End.Row; $r++) {
                $type = $ws.Cells[$r,$typeCol].Value
                if ($type -eq 'Dynamic') {
                    $ws.Cells[$r,$typeCol].Style.Fill.PatternType = [OfficeOpenXml.Style.ExcelFillStyle]::Solid
                    $ws.Cells[$r,$typeCol].Style.Fill.BackgroundColor.SetColor($clrAmber)
                }
            }
        }
        Close-ExcelPackage $pkg
    }

    #-- Remaining sheets ---------------------------------------------------------
    $remaining = [ordered]@{
        'vNetwork'     = $allVNetwork
        'vSnapshot'    = $allVSnapshot
        'vHost'        = $allVHost
        'vSwitch'      = $allVSwitch
        'vReplication' = $allVReplication
        'vIntegration' = $allVIntegration
    }

    foreach ($sheet in $remaining.GetEnumerator()) {
        if ($sheet.Value.Count -eq 0) {
            Write-Host "  Skipping empty sheet: $($sheet.Key)" -ForegroundColor Gray
            continue
        }
        Write-Host "  Writing: $($sheet.Key) ($($sheet.Value.Count) rows)" -ForegroundColor Green
        $sheet.Value | Export-Excel -Path $excelFile -WorksheetName $sheet.Key `
            -AutoSize -AutoFilter -FreezeTopRow -BoldTopRow -TableStyle Medium2
    }

    # Colour-code vReplication health
    if ($allVReplication.Count -gt 0) {
        $pkg = Open-ExcelPackage -Path $excelFile
        $ws  = $pkg.Workbook.Worksheets['vReplication']
        $healthCol = $null
        for ($c = 1; $c -le $ws.Dimension.End.Column; $c++) {
            if ($ws.Cells[1,$c].Value -eq 'Replication Health') { $healthCol = $c; break }
        }
        if ($healthCol) {
            for ($r = 2; $r -le $ws.Dimension.End.Row; $r++) {
                $h    = $ws.Cells[$r,$healthCol].Value
                $fill = switch ($h) {
                    'Normal'  { $clrGreen }
                    'Warning' { $clrAmber }
                    'Critical'{ $clrRed }
                    default   { $clrBlue }
                }
                $ws.Cells[$r,$healthCol].Style.Fill.PatternType = [OfficeOpenXml.Style.ExcelFillStyle]::Solid
                $ws.Cells[$r,$healthCol].Style.Fill.BackgroundColor.SetColor($fill)
            }
        }
        Close-ExcelPackage $pkg
    }

    Write-Host "`n  Excel report: $excelFile" -ForegroundColor Cyan
}

#endregion

#region -- HTML output ----------------------------------------------------------

if ($useHtml) {
    Write-Section 'Writing HTML report'

    Add-Type -AssemblyName System.Web

    function Build-HtmlTable ($title, $data, $id) {
        if ($data.Count -eq 0) { return "<section><h2>$title</h2><p class='empty'>No data collected.</p></section>" }
        $props = $data[0].PSObject.Properties.Name
        $sb = [System.Text.StringBuilder]::new()
        [void]$sb.Append("<section id='tab-$id'>")
        [void]$sb.Append("<h2>$title <span class='badge'>$($data.Count)</span></h2>")
        [void]$sb.Append("<div class='search-wrap'><input class='search' data-table='tbl-$id' placeholder='Filter $title...' /></div>")
        [void]$sb.Append("<div class='table-wrap'><table id='tbl-$id' class='inv-table'>")
        [void]$sb.Append('<thead><tr>')
        foreach ($p in $props) { [void]$sb.Append("<th onclick='sortTable(`"tbl-$id`",$([array]::IndexOf($props,$p)))'>$(Escape-Html $p) <span class='sort-icon'>^v</span></th>") }
        [void]$sb.Append('</tr></thead><tbody>')
        foreach ($row in $data) {
            [void]$sb.Append('<tr>')
            foreach ($p in $props) {
                $val = $row.$p
                $cellClass = ''
                # State colouring on vInfo
                if ($p -eq 'State') {
                    $cellClass = switch ($val) { 'Running' { ' class="state-running"' } 'Off' { ' class="state-off"' } default { ' class="state-other"' } }
                }
                # Disk size colouring
                if ($p -eq 'File Size (GB)') {
                    $n = [double]$val
                    $cellClass = if ($n -ge 500) { ' class="disk-large"' } elseif ($n -ge 100) { ' class="disk-medium"' } else { ' class="disk-small"' }
                }
                # Replication health
                if ($p -eq 'Replication Health') {
                    $cellClass = switch ($val) { 'Normal' { ' class="state-running"' } 'Warning' { ' class="state-other"' } 'Critical' { ' class="state-off"' } default { '' } }
                }
                [void]$sb.Append("<td$cellClass>$(Escape-Html $val)</td>")
            }
            [void]$sb.Append('</tr>')
        }
        [void]$sb.Append('</tbody></table></div></section>')
        $sb.ToString()
    }

    $tabs = [ordered]@{
        'vInfo'        = @{ Title = 'Virtual Machines'; Data = $allVInfo }
        'vDisk'        = @{ Title = 'Virtual Disks';    Data = $allVDisk }
        'vNetwork'     = @{ Title = 'Network Adapters'; Data = $allVNetwork }
        'vSnapshot'    = @{ Title = 'Snapshots';        Data = $allVSnapshot }
        'vHost'        = @{ Title = 'Hosts';            Data = $allVHost }
        'vSwitch'      = @{ Title = 'Virtual Switches'; Data = $allVSwitch }
        'vReplication' = @{ Title = 'Replication';      Data = $allVReplication }
        'vIntegration' = @{ Title = 'Integration Svcs'; Data = $allVIntegration }
    }

    $navButtons = $tabs.GetEnumerator() | ForEach-Object {
        "<button class='tab-btn' onclick='showTab(`"tab-$($_.Key)`",this)'>$($_.Value.Title) <span class='badge'>$($_.Value.Data.Count)</span></button>"
    }

    $tabSections = $tabs.GetEnumerator() | ForEach-Object {
        Build-HtmlTable $_.Value.Title $_.Value.Data $_.Key
    }

    $runPct   = if ($totalVMs -gt 0) { [math]::Round($runningVMs / $totalVMs * 100) } else { 0 }
    $offPct   = if ($totalVMs -gt 0) { [math]::Round($offVMs     / $totalVMs * 100) } else { 0 }
    $otherPct = 100 - $runPct - $offPct

    $html = @"
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8"/>
<meta name="viewport" content="width=device-width,initial-scale=1"/>
<title>Hyper-V Inventory - $generatedAt</title>
<style>
  *{box-sizing:border-box;margin:0;padding:0}
  body{font-family:'Segoe UI',Arial,sans-serif;background:#f0f2f5;color:#222;font-size:13px}
  header{background:linear-gradient(135deg,#1e3a5f,#2d6cb0);color:#fff;padding:18px 28px;display:flex;align-items:center;gap:16px}
  .customer{margin-left:auto;text-align:right;font-size:16px;font-weight:600;opacity:.9}
  header h1{font-size:20px;font-weight:600;letter-spacing:.5px}
  header p{font-size:11px;opacity:.75;margin-top:2px}
  /* Dashboard cards */
  .dashboard{display:flex;flex-wrap:wrap;gap:14px;padding:18px 20px;background:#fff;border-bottom:1px solid #dde3ea}
  .card{background:#f7f9fc;border:1px solid #dde3ea;border-radius:8px;padding:14px 18px;min-width:140px;flex:1}
  .card h3{font-size:11px;text-transform:uppercase;letter-spacing:.6px;color:#667;margin-bottom:6px}
  .card .val{font-size:28px;font-weight:700;color:#1e3a5f}
  .card.green{border-left:4px solid #28a745}.card.green .val{color:#28a745}
  .card.red{border-left:4px solid #dc3545}.card.red .val{color:#dc3545}
  .card.amber{border-left:4px solid #ffc107}.card.amber .val{color:#b07800}
  .card.blue{border-left:4px solid #2d6cb0}.card.blue .val{color:#2d6cb0}

  /* VM state bar */
  .state-bar-wrap{padding:0 20px 14px;background:#fff}
  .state-bar-label{font-size:11px;color:#667;margin-bottom:4px}
  .state-bar{display:flex;height:18px;border-radius:4px;overflow:hidden;gap:2px}
  .state-bar span{display:flex;align-items:center;justify-content:center;font-size:10px;font-weight:600;color:#fff;transition:width .3s}
  .sb-run{background:#28a745}
  .sb-off{background:#dc3545}
  .sb-other{background:#ffc107;color:#333}

  /* Tab nav */
  .tab-nav{display:flex;flex-wrap:wrap;gap:6px;padding:12px 20px;background:#fff;border-bottom:1px solid #dde3ea;position:sticky;top:0;z-index:10;box-shadow:0 2px 4px rgba(0,0,0,.06)}
  .tab-btn{background:#f0f2f5;border:1px solid #ccd3dc;border-radius:5px;padding:6px 12px;cursor:pointer;font-size:12px;font-family:inherit;transition:all .15s}
  .tab-btn:hover{background:#e2e8f0}
  .tab-btn.active{background:#1e3a5f;color:#fff;border-color:#1e3a5f}
  .badge{background:rgba(0,0,0,.15);border-radius:10px;padding:1px 6px;font-size:10px;margin-left:4px}
  .tab-btn.active .badge{background:rgba(255,255,255,.25)}

  /* Tables */
  section{display:none;padding:16px 20px}
  section.visible{display:block}
  .empty{color:#999;font-style:italic;padding:12px 0}
  .search-wrap{margin-bottom:10px}
  .search{width:320px;max-width:100%;padding:7px 11px;border:1px solid #ccd3dc;border-radius:5px;font-size:12px;font-family:inherit}
  .search:focus{outline:none;border-color:#2d6cb0;box-shadow:0 0 0 2px rgba(45,108,176,.15)}
  .table-wrap{overflow-x:auto;border-radius:6px;border:1px solid #dde3ea}
  table.inv-table{width:100%;border-collapse:collapse;font-size:12px}
  .inv-table thead{background:#1e3a5f;color:#fff;position:sticky;top:0}
  .inv-table th{padding:8px 10px;text-align:left;white-space:nowrap;cursor:pointer;user-select:none;font-weight:600}
  .inv-table th:hover{background:#2d4f7a}
  .sort-icon{opacity:.5;font-size:10px}
  .inv-table td{padding:7px 10px;border-bottom:1px solid #eef0f3;white-space:nowrap}
  .inv-table tbody tr:hover{background:#f0f5ff}
  .inv-table tbody tr:nth-child(even){background:#f7f9fc}
  .inv-table tbody tr:nth-child(even):hover{background:#e8f0fe}

  /* State colours */
  td.state-running{background:#d4edda;color:#155724;font-weight:700;border-radius:3px}
  td.state-off{background:#f8d7da;color:#721c24;font-weight:700;border-radius:3px}
  td.state-other{background:#fff3cd;color:#856404;font-weight:700;border-radius:3px}

  /* Disk size colours */
  td.disk-large{background:#f8d7da;color:#721c24;font-weight:600}
  td.disk-medium{background:#fff3cd;color:#856404;font-weight:600}
  td.disk-small{background:#d4edda;color:#155724}

  footer{text-align:center;padding:16px;color:#999;font-size:11px;border-top:1px solid #dde3ea;margin-top:20px}
</style>
</head>
<body>

<header>
  <div>
    <h1>Hyper-V Inventory Report</h1>
    <p>Generated: $generatedAt &nbsp;|&nbsp; Host(s): $($ComputerName -join ', ')</p>
  </div>
  <div class="customer">Prepared for: Customer Name</div>
</header>

<div class="dashboard">
  <div class="card blue"><h3>Total VMs</h3><div class="val">$totalVMs</div></div>
  <div class="card green"><h3>Running</h3><div class="val">$runningVMs</div></div>
  <div class="card red"><h3>Off</h3><div class="val">$offVMs</div></div>
  <div class="card amber"><h3>Other State</h3><div class="val">$savedVMs</div></div>
  <div class="card blue"><h3>Total vCPUs</h3><div class="val">$totalvCPU</div></div>
  <div class="card blue"><h3>Assigned RAM (GB)</h3><div class="val">$([math]::Round($totalRAM,1))</div></div>
  <div class="card blue"><h3>Disk Used (GB)</h3><div class="val">$([math]::Round($totalDiskGB,1))</div></div>
  <div class="card blue"><h3>Snapshots</h3><div class="val">$totalSnaps</div></div>
</div>

<div class="state-bar-wrap">
  <div class="state-bar-label">VM State Distribution</div>
  <div class="state-bar">
    <span class="sb-run"  style="width:$runPct%">$runPct%</span>
    <span class="sb-off"  style="width:$offPct%">$offPct%</span>
    <span class="sb-other"style="width:$otherPct%">$otherPct%</span>
  </div>
</div>

<nav class="tab-nav">
  $($navButtons -join "`n  ")
</nav>

$($tabSections -join "`n")

<footer>Hyper-V Inventory &nbsp;|&nbsp; $generatedAt &nbsp;|&nbsp; Generated by HyperV-Inventory.ps1</footer>

<script>
function showTab(id, btn) {
  document.querySelectorAll('section').forEach(s => s.classList.remove('visible'));
  document.querySelectorAll('.tab-btn').forEach(b => b.classList.remove('active'));
  var el = document.getElementById(id);
  if (el) el.classList.add('visible');
  if (btn) btn.classList.add('active');
}

function sortTable(tableId, colIdx) {
  var tbl = document.getElementById(tableId);
  var rows = Array.from(tbl.querySelectorAll('tbody tr'));
  var asc  = tbl.dataset.sortCol == colIdx && tbl.dataset.sortDir == 'asc' ? false : true;
  tbl.dataset.sortCol = colIdx;
  tbl.dataset.sortDir = asc ? 'asc' : 'desc';
  rows.sort(function(a,b) {
    var av = a.cells[colIdx] ? a.cells[colIdx].innerText : '';
    var bv = b.cells[colIdx] ? b.cells[colIdx].innerText : '';
    var an = parseFloat(av), bn = parseFloat(bv);
    if (!isNaN(an) && !isNaN(bn)) return asc ? an-bn : bn-an;
    return asc ? av.localeCompare(bv) : bv.localeCompare(av);
  });
  var tbody = tbl.querySelector('tbody');
  rows.forEach(function(r){ tbody.appendChild(r); });
}

document.querySelectorAll('.search').forEach(function(inp){
  inp.addEventListener('input', function(){
    var val = this.value.toLowerCase();
    var tbl = document.getElementById(this.dataset.table);
    if (!tbl) return;
    tbl.querySelectorAll('tbody tr').forEach(function(row){
      row.style.display = row.innerText.toLowerCase().includes(val) ? '' : 'none';
    });
  });
});

// Show first tab by default
var firstBtn = document.querySelector('.tab-btn');
if (firstBtn) firstBtn.click();
</script>
</body>
</html>
"@

    $html | Out-File -FilePath $htmlFile -Encoding UTF8
    Write-Host "  HTML report: $htmlFile" -ForegroundColor Cyan
}

#endregion

#region -- CSV output -----------------------------------------------------------

if ($useCsv) {
    Write-Section 'Writing CSV files'
    $sheets = [ordered]@{
        'vInfo'='vInfo';'vDisk'='vDisk';'vNetwork'='vNetwork';'vSnapshot'='vSnapshot'
        'vHost'='vHost';'vSwitch'='vSwitch';'vReplication'='vReplication';'vIntegration'='vIntegration'
    }
    $dataMap = @{
        'vInfo'=$allVInfo;'vDisk'=$allVDisk;'vNetwork'=$allVNetwork;'vSnapshot'=$allVSnapshot
        'vHost'=$allVHost;'vSwitch'=$allVSwitch;'vReplication'=$allVReplication;'vIntegration'=$allVIntegration
    }
    foreach ($s in $sheets.Keys) {
        $csvPath = "${csvBase}_$s.csv"
        $dataMap[$s] | Export-Csv -Path $csvPath -NoTypeInformation -Encoding UTF8
        Write-Host "  CSV: $csvPath" -ForegroundColor Green
    }
}

#endregion

#region -- Console summary ------------------------------------------------------

Write-Section 'Inventory Summary'
Write-Host "  Hosts inventoried : $($ComputerName.Count)"                 -ForegroundColor White
Write-Host "  Total VMs         : $totalVMs"                              -ForegroundColor White
Write-Host "    Running         : $runningVMs"                            -ForegroundColor Green
Write-Host "    Off             : $offVMs"                                -ForegroundColor Red
Write-Host "    Other           : $savedVMs"                              -ForegroundColor Yellow
Write-Host "  Total vCPUs       : $totalvCPU"                             -ForegroundColor White
Write-Host "  Total RAM (GB)    : $([math]::Round($totalRAM,2))"          -ForegroundColor White
Write-Host "  Total Disk (GB)   : $([math]::Round($totalDiskGB,2))"       -ForegroundColor White
Write-Host "  Total vDisks      : $totalDisks"                            -ForegroundColor White
Write-Host "  Total vNICs       : $totalNICs"                             -ForegroundColor White
Write-Host "  Total Snapshots   : $totalSnaps"                            -ForegroundColor White
Write-Host "  Virtual Switches  : $totalSwitches"                         -ForegroundColor White
Write-Host "  Replicated VMs    : $totalReplVMs"                          -ForegroundColor White
Write-Host ''

if ($useExcel) { Write-Host "  [Excel] $excelFile" -ForegroundColor Cyan }
if ($useHtml)  { Write-Host "  [HTML]  $htmlFile"  -ForegroundColor Cyan }
Write-Host ''

#endregion