# Complete Interactive Laptop Diagnostic Tool - Enhanced v15.1
# Version: 15.1 - Remote Execution & Hardware Detection Fixes
# Developer: Hybrid Systems

$ErrorActionPreference = "SilentlyContinue"

# File-safe timestamp (used in report filename)
$timestamp = Get-Date -Format 'yyyyMMdd_HHmmss'

# Human-friendly timestamp (used in HTML display)
$timestampDisplay = Get-Date -Format 'dd MMM yyyy, hh:mm tt'

# Avoid repeated self-elevation loops for WMI auto-enable.
$script:__wmiAutoElevateAttempted = $false

# ============================================================
# PROGRESS LOADER FUNCTION
# ============================================================
$script:totalSteps = 21
$script:currentStep = 0

function Show-Progress {
    param(
        [string]$Status,
        [int]$Step = -1
    )

    if ($Step -ge 0) {
        $script:currentStep = $Step
    } else {
        $script:currentStep++
    }

    $percent = [math]::Round(($script:currentStep / $script:totalSteps) * 100)
    $barLength = 40
    $filledLength = [math]::Round($barLength * $script:currentStep / $script:totalSteps)
    $emptyLength = $barLength - $filledLength

    $filledBar = [string]::new([char]0x2588, $filledLength)
    $emptyBar = [string]::new([char]0x2591, $emptyLength)

    # Clear line and write progress
    Write-Host "`r                                                                              " -NoNewline
    Write-Host "`r  [$filledBar$emptyBar] $percent% - $Status" -NoNewline -ForegroundColor Cyan
}

function Show-Header {
    Clear-Host
    Write-Host ""
    Write-Host "  ============================================================" -ForegroundColor Magenta
    Write-Host "       HARDWARE DIAGNOSTIC TOOL | HYBRID SYSTEMS" -ForegroundColor White
    Write-Host "  ============================================================" -ForegroundColor Magenta
    Write-Host ""
}

function Show-Complete {
    Write-Host "`r                                                                              " -NoNewline
    Write-Host "`r  [" -NoNewline -ForegroundColor Green
    Write-Host "$([string]::new([char]0x2588, 40))" -NoNewline -ForegroundColor Green
    Write-Host "] 100% - Complete!" -ForegroundColor Green
    Write-Host ""
    Write-Host "  ============================================================" -ForegroundColor Green
    Write-Host "       DIAGNOSTIC COMPLETE - Opening Report..." -ForegroundColor White
    Write-Host "  ============================================================" -ForegroundColor Green
    Write-Host ""
}

# Show header
Show-Header

# ============================================================
# REMOTE EXECUTION DETECTION
# ============================================================
# Detect if script is running via irm | iex (remote execution)
$isRemoteExecution = $false
$scriptDir = $null
$remoteServerUrl = "https://test.hybridsystems.org"  # Configure your server URL here
$remoteReportsPath = "C:\xampp\htdocs\reports"       # Web-accessible directory on server
$remoteReportsUrl = "$remoteServerUrl/reports"       # Public URL for reports

# Check multiple indicators for remote execution
if ([string]::IsNullOrEmpty($MyInvocation.MyCommand.Path)) {
    $isRemoteExecution = $true
} elseif ($MyInvocation.MyCommand.CommandType -eq "ExternalScript" -and -not (Test-Path $MyInvocation.MyCommand.Path -ErrorAction SilentlyContinue)) {
    $isRemoteExecution = $true
} elseif ($MyInvocation.InvocationName -match "^Invoke-Expression|^iex$") {
    $isRemoteExecution = $true
}

# Set paths based on execution context (silent)
if ($isRemoteExecution) {
    # For remote execution, try multiple possible web server paths
    $possiblePaths = @(
        $remoteReportsPath,
        "C:\xampp\htdocs\laptop-diagnostic-tool-main\reports",
        "C:\inetpub\wwwroot\reports",
        "C:\wamp\www\reports",
        "C:\wamp64\www\reports"
    )

    $serverPathFound = $false
    foreach ($path in $possiblePaths) {
        try {
            if (-not (Test-Path $path)) {
                New-Item -ItemType Directory -Path $path -Force -ErrorAction Stop | Out-Null
            }
            $testFile = Join-Path $path ".write_test_$(Get-Random).tmp"
            [System.IO.File]::WriteAllText($testFile, "test")
            Remove-Item $testFile -Force -ErrorAction SilentlyContinue

            $outputDir = $path
            $scriptDir = Split-Path -Parent $path
            $serverPathFound = $true
            break
        } catch {
            continue
        }
    }

    if (-not $serverPathFound) {
        $outputDir = Join-Path ([Environment]::GetFolderPath("Desktop")) "DiagnosticReports"
        $scriptDir = [Environment]::GetFolderPath("Desktop")
    }
} else {
    # Local execution - use script directory
    $scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
    $outputDir = Join-Path $scriptDir "reports"
}

# Ensure output directory exists
New-Item -ItemType Directory -Path $outputDir -Force | Out-Null

# Initialize scoring variables
$globalScore = 0
$globalScoreMax = 0
$performanceScore = 0
$scoreBreakdown = @()
$testData = @{}

# Load hardware database and upgrade recommendations
# For remote execution, try to download from server or use embedded defaults
$hardwareDB = $null
$upgradeDB = $null

if (-not $isRemoteExecution -and $scriptDir) {
    $hardwareDBPath = Join-Path $scriptDir "hardware_database.json"
    $upgradeDBPath = Join-Path $scriptDir "upgrade_recommendations.json"

    if (Test-Path $hardwareDBPath) {
        $hardwareDB = Get-Content $hardwareDBPath -Raw | ConvertFrom-Json
    }
    if (Test-Path $upgradeDBPath) {
        $upgradeDB = Get-Content $upgradeDBPath -Raw | ConvertFrom-Json
    }
} else {
    # Remote execution: try to fetch from server
    try {
        $hardwareDB = Invoke-RestMethod "$remoteServerUrl/hardware_database.json" -ErrorAction SilentlyContinue
    } catch {
        # Silent fail - will use embedded defaults
    }
    try {
        $upgradeDB = Invoke-RestMethod "$remoteServerUrl/upgrade_recommendations.json" -ErrorAction SilentlyContinue
    } catch {
        # Silent fail - will use embedded defaults
    }
}

#region Helper Functions (keeping existing ones and adding new)

function Ensure-WmiServiceRunning {
    # Best-effort: if WMI service is stopped/disabled, try to enable and start it.
    # This avoids blank/empty sections when Win10/11 has Winmgmt stopped.
    $result = @{ Running = $false; Started = $false; StartupType = "Unknown"; Message = ""; ElevationRequested = $false }
    try {
        $isAdmin = $false
        try {
            $isAdmin = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
        } catch { $isAdmin = $false }

        $svc = Get-Service -Name "Winmgmt" -ErrorAction Stop
        $result.StartupType = try { (Get-CimInstance -ClassName Win32_Service -Filter "Name='Winmgmt'" -ErrorAction Stop).StartMode } catch { "Unknown" }

        if ($svc.Status -ne "Running") {
            try {
                # If disabled, attempt to set to Automatic (requires admin; safe to fail).
                if ($result.StartupType -eq "Disabled") {
                    if ($isAdmin) {
                        try { Set-Service -Name "Winmgmt" -StartupType Automatic -ErrorAction Stop } catch { }
                    } else {
                        # Best-effort: attempt to relaunch the script elevated so we can enable/start WMI.
                        if (-not $script:__wmiAutoElevateAttempted -and $MyInvocation -and $MyInvocation.MyCommand -and $MyInvocation.MyCommand.Path -and (Test-Path $MyInvocation.MyCommand.Path -ErrorAction SilentlyContinue)) {
                            $script:__wmiAutoElevateAttempted = $true
                            try {
                                $scriptPath = $MyInvocation.MyCommand.Path
                                $argsList = "-NoProfile -ExecutionPolicy Bypass -File `"$scriptPath`""
                                Start-Process -FilePath "powershell.exe" -ArgumentList $argsList -Verb RunAs | Out-Null
                                $result.ElevationRequested = $true
                                $result.Message = "WMI service is Disabled. Re-launching as Administrator to enable/start WMI (accept the UAC prompt)."
                                return $result
                            } catch {
                                $result.Message = "WMI service is Disabled. Run this script as Administrator to enable/start Winmgmt automatically."
                            }
                        } else {
                            $result.Message = "WMI service is Disabled. Run this script as Administrator to enable/start Winmgmt automatically."
                        }
                    }
                }
                Start-Service -Name "Winmgmt" -ErrorAction Stop
                $result.Started = $true
            } catch {
                $result.Message = "Unable to start WMI (Winmgmt): $($_.Exception.Message)"
            }
        }

        # Refresh status
        try { $svc = Get-Service -Name "Winmgmt" -ErrorAction Stop } catch { }
        $result.Running = ($svc -and $svc.Status -eq "Running")
        if (-not $result.Message) {
            $result.Message = if ($result.Running) { "WMI service is running" } else { "WMI service is not running" }
        }
    } catch {
        $result.Message = "WMI service (Winmgmt) not found or not accessible: $($_.Exception.Message)"
    }
    return $result
}

function Get-ApproxCpuTier {
    param([string]$Name)

    if ([string]::IsNullOrWhiteSpace($Name)) { return $null }
    $n = $Name

    # Apple Silicon
    if ($n -match "(?i)\bM([1-3])\b") {
        $mGen = [int]$matches[1]
        $year = if ($mGen -eq 1) { 2020 } elseif ($mGen -eq 2) { 2022 } else { 2023 }
        $base = if ($mGen -eq 1) { 70 } elseif ($mGen -eq 2) { 76 } else { 82 }
        $bonus = 0
        if ($n -match "(?i)Ultra") { $bonus = 18 }
        elseif ($n -match "(?i)Max") { $bonus = 12 }
        elseif ($n -match "(?i)Pro") { $bonus = 8 }
        $score = [math]::Min(100, $base + $bonus)
        $tier = if ($score -ge 92) { "Flagship" } elseif ($score -ge 82) { "High Performance" } elseif ($score -ge 70) { "Mainstream" } else { "Mid-Range" }
        return @{ Tier = $tier; Score = [int]$score; Category = "CPU"; EstimatedYear = $year }
    }

		    # Intel Xeon W-series (common workstation naming: "Intel(R) Xeon(R) W-2235 CPU @ ...")
		    if ($n -match "(?i)\bXeon\b.*\bW-?(\d{4})\b") {
		        $model = 0
		        try { $model = [int]$matches[1] } catch { $model = 0 }
		
		        # Coarse series mapping (best-effort fallback). Prefer database patterns when available.
		        # NOTE: W-2235 (6C/12T) is a solid workstation CPU but not a flagship-tier part.
		        $score = 80
		        $year = 2019
		        if ($model -ge 3400) { $score = 96; $year = 2024 }
		        elseif ($model -ge 2400) { $score = 94; $year = 2023 }
		        elseif ($model -ge 2200) {
		            $year = 2019
		            if ($model -ge 2270) { $score = 85 } else { $score = 70 }
		        }
		        elseif ($model -ge 2100) { $score = 75; $year = 2017 }
		        elseif ($model -ge 1300) { $score = 80; $year = 2021 }
		        elseif ($model -ge 1200) { $score = 76; $year = 2020 }
		
		        $tier = if ($score -ge 92) { "Flagship" } elseif ($score -ge 82) { "High Performance" } elseif ($score -ge 70) { "Mainstream" } elseif ($score -ge 55) { "Mid-Range" } elseif ($score -ge 40) { "Entry Level" } else { "Legacy" }
		        return @{ Tier = $tier; Score = [int]$score; Category = "CPU"; EstimatedYear = $year }
		    }

    # Intel Core i3/i5/i7/i9
    if ($n -match "(?i)\b(i[3579])[-\s]?(\d{4,5})([A-Za-z0-9]{0,6})\b") {
        $cls = $matches[1].ToLower()
        $digits = $matches[2]
        $suffix = $matches[3]

        $gen = 0
        if ($digits.Length -ge 5) { $gen = [int]$digits.Substring(0,2) }
        elseif ($digits.Length -eq 4) {
            $first2 = [int]$digits.Substring(0,2)
            $gen = if ($first2 -ge 10) { $first2 } else { [int]$digits.Substring(0,1) }
        }

        $genBase = switch ($gen) {
            14 { 78 } 13 { 76 } 12 { 73 } 11 { 70 } 10 { 67 }
            9 { 64 } 8 { 61 } 7 { 56 } 6 { 52 } 5 { 48 }
            4 { 42 } 3 { 35 } 2 { 28 } default { 22 }
        }
        $classBonus = switch ($cls) { "i9" { 18 } "i7" { 12 } "i5" { 6 } default { 0 } }
        $suffixAdj = 0
        if ($suffix -match "(?i)HX") { $suffixAdj += 4 }
        elseif ($suffix -match "(?i)H") { $suffixAdj += 3 }
        elseif ($suffix -match "(?i)P") { $suffixAdj += 1 }
        if ($suffix -match "(?i)K") { $suffixAdj += 2 }
        if ($suffix -match "(?i)U") { $suffixAdj -= 2 }
        if ($suffix -match "(?i)Y") { $suffixAdj -= 3 }

        $minor = 0
        try {
            $last2 = [int]$digits.Substring($digits.Length-2, 2)
            $minor = [math]::Round((($last2 / 99.0) * 4.0) - 2.0)
        } catch { }

        $score = [math]::Max(0, [math]::Min(100, ($genBase + $classBonus + $suffixAdj + $minor)))
        $year = switch ($gen) {
            14 { 2023 } 13 { 2022 } 12 { 2021 } 11 { 2020 } 10 { 2019 }
            9 { 2018 } 8 { 2017 } 7 { 2016 } 6 { 2015 } 5 { 2014 }
            4 { 2013 } 3 { 2012 } 2 { 2011 } default { 2010 }
        }
        $tier = if ($score -ge 92) { "Flagship" } elseif ($score -ge 82) { "High Performance" } elseif ($score -ge 70) { "Mainstream" } elseif ($score -ge 55) { "Mid-Range" } elseif ($score -ge 40) { "Entry Level" } else { "Legacy" }
        return @{ Tier = $tier; Score = [int]$score; Category = "CPU"; EstimatedYear = $year }
    }

    # AMD Ryzen
    if ($n -match "(?i)\bRyzen\s+(3|5|7|9)\s+(\d{4,5})([A-Za-z0-9]{0,6})\b") {
        $cls = [int]$matches[1]
        $digits = $matches[2]
        $suffix = $matches[3]
        $fam = [int]$digits.Substring(0,1) # 1xxx..9xxx

        $famBase = switch ($fam) { 9 { 84 } 8 { 82 } 7 { 78 } 6 { 74 } 5 { 70 } 4 { 66 } 3 { 60 } 2 { 54 } 1 { 48 } default { 40 } }
        $classBonus = switch ($cls) { 9 { 14 } 7 { 9 } 5 { 5 } default { 0 } }
        $suffixAdj = 0
        if ($suffix -match "(?i)X3D") { $suffixAdj += 4 }
        elseif ($suffix -match "(?i)X") { $suffixAdj += 2 }
        if ($suffix -match "(?i)U") { $suffixAdj -= 2 }
        if ($suffix -match "(?i)H") { $suffixAdj += 2 }

        $minor = 0
        try {
            $last2 = [int]$digits.Substring($digits.Length-2, 2)
            $minor = [math]::Round((($last2 / 99.0) * 4.0) - 2.0)
        } catch { }

        $score = [math]::Max(0, [math]::Min(100, ($famBase + $classBonus + $suffixAdj + $minor)))
        $year = switch ($fam) { 9 { 2024 } 8 { 2024 } 7 { 2022 } 6 { 2020 } 5 { 2020 } 4 { 2019 } 3 { 2017 } 2 { 2018 } 1 { 2017 } default { 2016 } }
        $tier = if ($score -ge 92) { "Flagship" } elseif ($score -ge 82) { "High Performance" } elseif ($score -ge 70) { "Mainstream" } elseif ($score -ge 55) { "Mid-Range" } elseif ($score -ge 40) { "Entry Level" } else { "Legacy" }
        return @{ Tier = $tier; Score = [int]$score; Category = "CPU"; EstimatedYear = $year }
    }

    # Legacy families (very coarse)
    if ($n -match "(?i)\b(Core\s*2|Athlon|Phenom|FX[-\s]?\d|A\d-\d)\b") {
        return @{ Tier = "Legacy"; Score = 20; Category = "CPU"; EstimatedYear = 2010 }
    }

    return $null
}

function Get-ApproxGpuTier {
    param([string]$Name)

    if ([string]::IsNullOrWhiteSpace($Name)) { return $null }
    $n = $Name

    # NVIDIA RTX #### (+Ti/+SUPER)
    if ($n -match "(?i)\bRTX\s*(\d{4})\b") {
        $model = [int]$matches[1]
        $series = [int]([math]::Floor($model / 100))
        $cls = $model % 100
        $base = switch ($series) { 50 { 92 } 40 { 88 } 30 { 80 } 20 { 70 } default { 65 } }
        $adj = switch ($cls) { 90 { 10 } 80 { 7 } 70 { 5 } 60 { 2 } 50 { -2 } 40 { -5 } 30 { -8 } default { -10 } }
        if ($n -match "(?i)Ti") { $adj += 2 }
        if ($n -match "(?i)SUPER") { $adj += 1 }
        $score = [math]::Max(0, [math]::Min(100, $base + $adj))
        $year = switch ($series) { 50 { 2025 } 40 { 2022 } 30 { 2020 } 20 { 2018 } default { 2017 } }
        $tier = if ($score -ge 95) { "Flagship" } elseif ($score -ge 86) { "High Performance" } elseif ($score -ge 76) { "Performance" } elseif ($score -ge 62) { "Mainstream" } elseif ($score -ge 45) { "Entry Level" } else { "Budget" }
        return @{ Tier = $tier; Score = [int]$score; Category = "GPU"; EstimatedYear = $year }
    }

    # NVIDIA GTX #### / ###
    if ($n -match "(?i)\bGTX\s*(\d{3,4})\b") {
        $model = [int]$matches[1]
        $series = if ($model -ge 1000) { [int]([math]::Floor($model / 100)) } else { [int]([math]::Floor($model / 10)) }
        $cls = $model % 100
        $base = switch ($series) { 16 { 62 } 10 { 60 } 9 { 52 } 7 { 45 } 6 { 38 } default { 32 } }
        $adj = switch ($cls) { 80 { 5 } 70 { 3 } 60 { 1 } 50 { -2 } default { -5 } }
        if ($n -match "(?i)Ti") { $adj += 2 }
        $score = [math]::Max(0, [math]::Min(100, $base + $adj))
        $year = if ($series -ge 16) { 2019 } elseif ($series -ge 10) { 2016 } elseif ($series -ge 9) { 2014 } else { 2013 }
        $tier = if ($score -ge 76) { "Performance" } elseif ($score -ge 62) { "Mainstream" } elseif ($score -ge 45) { "Entry Level" } else { "Budget" }
        return @{ Tier = $tier; Score = [int]$score; Category = "GPU"; EstimatedYear = $year }
    }

    # AMD Radeon RX #### / ##### (+XT/+XTX)
    if ($n -match "(?i)\bRX\s*(\d{4,5})\b") {
        $digits = $matches[1]
        $fam = [int]$digits.Substring(0,1) # 4/5/6/7
        $base = switch ($fam) { 7 { 86 } 6 { 78 } 5 { 68 } 4 { 55 } default { 45 } }
        $adj = 0
        if ($n -match "(?i)XTX") { $adj += 5 }
        elseif ($n -match "(?i)XT") { $adj += 3 }
        $last2 = 0
        try { $last2 = [int]$digits.Substring($digits.Length-2,2) } catch { }
        if ($last2 -ge 80) { $adj += 5 }
        elseif ($last2 -ge 70) { $adj += 3 }
        elseif ($last2 -ge 60) { $adj += 1 }
        elseif ($last2 -ge 50) { $adj += 0 }
        else { $adj -= 2 }
        $score = [math]::Max(0, [math]::Min(100, $base + $adj))
        $year = switch ($fam) { 7 { 2022 } 6 { 2020 } 5 { 2019 } 4 { 2016 } default { 2015 } }
        $tier = if ($score -ge 95) { "Flagship" } elseif ($score -ge 86) { "High Performance" } elseif ($score -ge 76) { "Performance" } elseif ($score -ge 62) { "Mainstream" } elseif ($score -ge 45) { "Entry Level" } else { "Budget" }
        return @{ Tier = $tier; Score = [int]$score; Category = "GPU"; EstimatedYear = $year }
    }

    # Intel Arc
    if ($n -match "(?i)\bArc\s*A(\d{3,4})\b") {
        $m = [int]$matches[1]
        $score = if ($m -ge 750) { 68 } elseif ($m -ge 700) { 64 } elseif ($m -ge 580) { 58 } elseif ($m -ge 380) { 42 } else { 35 }
        $tier = if ($score -ge 62) { "Mainstream" } elseif ($score -ge 45) { "Entry Level" } else { "Budget" }
        return @{ Tier = $tier; Score = $score; Category = "GPU"; EstimatedYear = 2022 }
    }

    # Integrated (coarse)
    if ($n -match "(?i)Iris\s*Xe") { return @{ Tier = "Integrated Plus"; Score = 38; Category = "GPU"; EstimatedYear = 2020 } }
    if ($n -match "(?i)Iris\s*Plus") { return @{ Tier = "Integrated"; Score = 32; Category = "GPU"; EstimatedYear = 2019 } }
    if ($n -match "(?i)UHD|Intel\s*HD") { return @{ Tier = "Integrated"; Score = 22; Category = "GPU"; EstimatedYear = 2017 } }
    if ($n -match "(?i)Vega\s*(\d+)|Radeon\s+Graphics") { return @{ Tier = "Integrated"; Score = 28; Category = "GPU"; EstimatedYear = 2019 } }

    return $null
}

# --- Exact-match benchmark lookups (optional; populated by Update-HardwareDatabase.ps1) ---
$script:__exactMapsInitialized = $false
$script:__cpuExactMap = @{}
$script:__gpuExactMap = @{}
$script:__storageExactMap = @{}
$script:__ramExactMap = @{}
$script:__ramBinsByType = @{}

function Normalize-HardwareName {
    param([string]$Name)
    if ([string]::IsNullOrWhiteSpace($Name)) { return "" }
    $s = ($Name -as [string]).ToUpperInvariant()
    # Remove common vendor/noise tokens so that e.g. "NVIDIA GeForce RTX 4090" matches "GeForce RTX 4090".
    $s = $s -replace "\(R\)|\(TM\)", ""
    $s = $s -replace "\bNVIDIA\b|\bAMD\b|\bATI\b|\bINTEL\b|\bCORPORATION\b|\bINC\b", ""
    $s = $s -replace "\bGRAPHICS\b|\bADAPTER\b|\bMOBILE\b|\bLAPTOP\b|\bWITH\b", ""
    # Strip all non-alphanumerics for robust matching.
    $s = $s -replace "[^A-Z0-9]+", ""
    return $s
}

# Storage names vary heavily between WMI and benchmark sites (vendor order, NVMe tokens, capacity units).
# This normalizer is used only for *storage* matching as a fallback key.
function Normalize-StorageMatchKey {
    param([string]$Name)
    if ([string]::IsNullOrWhiteSpace($Name)) { return "" }
    $s = ($Name -as [string]).ToUpperInvariant()
    $s = $s -replace "\(R\)|\(TM\)", ""

    # Remove common manufacturer tokens
    $s = $s -replace "\bSAMSUNG\b|\bSEAGATE\b|\bTOSHIBA\b|\bHGST\b|\bHITACHI\b|\bWESTERN\s*DIGITAL\b|\bWDC\b|\bSANDISK\b|\bKINGSTON\b|\bMICRON\b|\bCRUCIAL\b|\bSK\s*HYNIX\b|\bHYNIX\b|\bINTEL\b|\bADATA\b|\bCORSAIR\b|\bTEAMGROUP\b|\bPNY\b", ""

    # Remove technology/capacity noise
    $s = $s -replace "\bNVME\b|\bNVM\s*E\b|\bSSD\b|\bHDD\b|\bM\.2\b|\bPCIE\b|\bPCI\s*E\b|\bSATA\b|\bSAS\b|\bUSB\b", ""
    $s = $s -replace "\b[0-9]+\s*(GB|TB)\b", ""

    $s = $s -replace "[^A-Z0-9]+", ""
    return $s
}

function Get-DisplayConnectorCounts {
    param([string]$ConnectorString)

    $counts = @{ HDMI = 0; DisplayPort = 0; DVI = 0; VGA = 0; USBC = 0; Total = 0; Source = "None" }
    if ([string]::IsNullOrWhiteSpace($ConnectorString)) { return $counts }

    $counts.Source = "DBGPU"
    $s = ("" + $ConnectorString)
    $parts = $s -split "[,;/\r\n]+" | ForEach-Object { $_.Trim() } | Where-Object { $_ }
    foreach ($p in $parts) {
        $seg = ("" + $p)
        $n = 1
        if ($seg -match '(?i)\bx\s*([0-9]+)\b') { $n = [int]$Matches[1] }
        elseif ($seg -match '(?i)\b([0-9]+)\s*x\b') { $n = [int]$Matches[1] }

        if ($seg -match '(?i)HDMI') { $counts.HDMI += $n }
        elseif ($seg -match '(?i)DISPLAY\s*PORT|MINI\s*DP|\bMDP\b') { $counts.DisplayPort += $n }
        elseif ($seg -match '(?i)\bDVI\b') { $counts.DVI += $n }
        elseif ($seg -match '(?i)\bVGA\b|HD15|D-?SUB') { $counts.VGA += $n }
        elseif ($seg -match '(?i)USB\s*-?\s*C|TYPE\s*-?\s*C|VIRTUALLINK') { $counts.USBC += $n }
    }

    $counts.Total = ($counts.HDMI + $counts.DisplayPort + $counts.DVI + $counts.VGA + $counts.USBC)
    return $counts
}

function Initialize-HardwareDatabaseExactMaps {
    param([object]$Database)

    $script:__cpuExactMap = @{}
    $script:__gpuExactMap = @{}
    $script:__storageExactMap = @{}
    $script:__ramExactMap = @{}
    $script:__ramBinsByType = @{}
    if (-not $Database) { return }

    # CPU exact map
    try {
        $cpuExact = $null
        if ($Database.cpus -and $Database.cpus.exact) { $cpuExact = $Database.cpus.exact }
        elseif ($Database.cpus_exact) { $cpuExact = $Database.cpus_exact }

        if ($cpuExact) {
            if ($cpuExact -is [System.Collections.IDictionary]) {
                foreach ($k in $cpuExact.Keys) {
                    $nk = Normalize-HardwareName -Name ("" + $k)
                    if ($nk) { $script:__cpuExactMap[$nk] = $cpuExact[$k] }
                }
            } else {
                foreach ($p in $cpuExact.PSObject.Properties) {
                    if ($p.MemberType -ne 'NoteProperty') { continue }

                    # Primary key: property name
                    $nk = Normalize-HardwareName -Name ("" + $p.Name)
                    if ($nk) { $script:__cpuExactMap[$nk] = $p.Value }

                    # Secondary key: embedded display name (if present)
                    $displayName = $null
                    try { $displayName = (("" + $p.Value.name).Trim()) } catch { $displayName = $null }
                    if ($displayName) {
                        $nk2 = Normalize-HardwareName -Name $displayName
                        if ($nk2 -and -not $script:__cpuExactMap.ContainsKey($nk2)) {
                            $script:__cpuExactMap[$nk2] = $p.Value
                        }
                    }
                }
            }
        }
    } catch { }

    # GPU exact map (supports legacy DB key: gpu)
    try {
        $gpuExact = $null
        if ($Database.gpus -and $Database.gpus.exact) { $gpuExact = $Database.gpus.exact }
        elseif ($Database.gpu -and $Database.gpu.exact) { $gpuExact = $Database.gpu.exact }
        elseif ($Database.gpus_exact) { $gpuExact = $Database.gpus_exact }

        if ($gpuExact) {
            if ($gpuExact -is [System.Collections.IDictionary]) {
                foreach ($k in $gpuExact.Keys) {
                    $nk = Normalize-HardwareName -Name ("" + $k)
                    if ($nk) { $script:__gpuExactMap[$nk] = $gpuExact[$k] }
                }
            } else {
                foreach ($p in $gpuExact.PSObject.Properties) {
                    if ($p.MemberType -ne 'NoteProperty') { continue }

                    # Primary key: property name
                    $nk = Normalize-HardwareName -Name ("" + $p.Name)
                    if ($nk) { $script:__gpuExactMap[$nk] = $p.Value }

                    # Secondary key: embedded display name (if present)
                    $displayName = $null
                    try { $displayName = (("" + $p.Value.name).Trim()) } catch { $displayName = $null }
                    if ($displayName) {
                        $nk2 = Normalize-HardwareName -Name $displayName
                        if ($nk2 -and -not $script:__gpuExactMap.ContainsKey($nk2)) {
                            $script:__gpuExactMap[$nk2] = $p.Value
                        }
                    }
                }
            }
        }
    } catch { }

	    # Storage exact map
	    try {
	        $storageExact = $null
	        if ($Database.storage -and $Database.storage.exact) { $storageExact = $Database.storage.exact }
	        elseif ($Database.storage_exact) { $storageExact = $Database.storage_exact }

	        if ($storageExact) {
	            if ($storageExact -is [System.Collections.IDictionary]) {
	                foreach ($k in $storageExact.Keys) {
	                    $nk = Normalize-HardwareName -Name ("" + $k)
	                    if ($nk) { $script:__storageExactMap[$nk] = $storageExact[$k] }

	                    # Fallback alias key: vendor/capacity-agnostic
	                    try {
	                        $ak = Normalize-StorageMatchKey -Name ("" + $k)
	                        if ($ak) {
	                            if (-not $script:__storageExactMap.ContainsKey($ak)) { $script:__storageExactMap[$ak] = $storageExact[$k] }
	                            else {
	                                $cur = $script:__storageExactMap[$ak]
	                                $curScore = try { [int]$cur.score } catch { try { [int]$cur.Score } catch { 0 } }
	                                $newScore = try { [int]$storageExact[$k].score } catch { try { [int]$storageExact[$k].Score } catch { 0 } }
	                                if ($newScore -gt $curScore) { $script:__storageExactMap[$ak] = $storageExact[$k] }
	                            }
	                        }
	                    } catch { }
	                }
	            } else {
	                foreach ($p in $storageExact.PSObject.Properties) {
	                    if ($p.MemberType -ne 'NoteProperty') { continue }
	                    $nk = Normalize-HardwareName -Name ("" + $p.Name)
	                    if ($nk) { $script:__storageExactMap[$nk] = $p.Value }

	                    # Fallback alias key: vendor/capacity-agnostic
	                    try {
	                        $ak = Normalize-StorageMatchKey -Name ("" + $p.Name)
	                        if ($ak) {
	                            if (-not $script:__storageExactMap.ContainsKey($ak)) { $script:__storageExactMap[$ak] = $p.Value }
	                            else {
	                                $cur = $script:__storageExactMap[$ak]
	                                $curScore = try { [int]$cur.score } catch { try { [int]$cur.Score } catch { 0 } }
	                                $newScore = try { [int]$p.Value.score } catch { try { [int]$p.Value.Score } catch { 0 } }
	                                if ($newScore -gt $curScore) { $script:__storageExactMap[$ak] = $p.Value }
	                            }
	                        }
	                    } catch { }

	                    $displayName = $null
	                    try { $displayName = (("" + $p.Value.name).Trim()) } catch { $displayName = $null }
	                    if ($displayName) {
	                        $nk2 = Normalize-HardwareName -Name $displayName
	                        if ($nk2 -and -not $script:__storageExactMap.ContainsKey($nk2)) {
	                            $script:__storageExactMap[$nk2] = $p.Value
	                        }

	                        # Alias from embedded name as well
	                        try {
	                            $ak2 = Normalize-StorageMatchKey -Name $displayName
	                            if ($ak2) {
	                                if (-not $script:__storageExactMap.ContainsKey($ak2)) { $script:__storageExactMap[$ak2] = $p.Value }
	                                else {
	                                    $cur = $script:__storageExactMap[$ak2]
	                                    $curScore = try { [int]$cur.score } catch { try { [int]$cur.Score } catch { 0 } }
	                                    $newScore = try { [int]$p.Value.score } catch { try { [int]$p.Value.Score } catch { 0 } }
	                                    if ($newScore -gt $curScore) { $script:__storageExactMap[$ak2] = $p.Value }
	                                }
	                            }
	                        } catch { }
	                    }
	                }
	            }
	        }
	    } catch { }

	    # RAM exact map
	    try {
	        $ramExact = $null
	        if ($Database.ram -and $Database.ram.exact) { $ramExact = $Database.ram.exact }
	        elseif ($Database.ram_exact) { $ramExact = $Database.ram_exact }

	        if ($ramExact) {
	            if ($ramExact -is [System.Collections.IDictionary]) {
	                foreach ($k in $ramExact.Keys) {
	                    $nk = Normalize-HardwareName -Name ("" + $k)
	                    if ($nk) { $script:__ramExactMap[$nk] = $ramExact[$k] }
	                }
	            } else {
	                foreach ($p in $ramExact.PSObject.Properties) {
	                    if ($p.MemberType -ne 'NoteProperty') { continue }
	                    $nk = Normalize-HardwareName -Name ("" + $p.Name)
	                    if ($nk) { $script:__ramExactMap[$nk] = $p.Value }

	                    $displayName = $null
	                    try { $displayName = (("" + $p.Value.name).Trim()) } catch { $displayName = $null }
	                    if ($displayName) {
	                        $nk2 = Normalize-HardwareName -Name $displayName
	                        if ($nk2 -and -not $script:__ramExactMap.ContainsKey($nk2)) {
	                            $script:__ramExactMap[$nk2] = $p.Value
	                        }
	                    }
	                }
	            }
	        }
	    } catch { }

	    # RAM bins (PassMark-derived summaries by DDR type + speed)
	    try {
	        $ramBins = $null
	        if ($Database.ram -and $Database.ram.bins) { $ramBins = $Database.ram.bins }
	        elseif ($Database.ram_bins) { $ramBins = $Database.ram_bins }

	        if ($ramBins) {
	            foreach ($b in @($ramBins)) {
	                $ddr = $null
	                try { $ddr = ("" + $b.ddrType).Trim() } catch { $ddr = $null }
	                if (-not $ddr) { try { $ddr = ("" + $b.DDRType).Trim() } catch { $ddr = $null } }
	                if (-not $ddr) { continue }
	                $ddr = $ddr.ToUpperInvariant()

	                if (-not $script:__ramBinsByType.ContainsKey($ddr)) { $script:__ramBinsByType[$ddr] = @() }
	                $script:__ramBinsByType[$ddr] += $b
	            }
	        }
	    } catch { }
}

function Get-HardwareTier {
    param([string]$ComponentType, [object]$ComponentName, [object]$Database)

    if (-not $Database) {
        return @{ Tier = "Unknown"; Score = 50; Category = "N/A" }
    }

    # Lazy-init exact maps once per run to avoid repeated JSON object enumeration.
    if (-not $script:__exactMapsInitialized) {
        Initialize-HardwareDatabaseExactMaps -Database $Database
        $script:__exactMapsInitialized = $true
    }

    $result = @{ Tier = "Unknown"; Score = 50; Category = "N/A"; EstimatedYear = 2020 }

    switch ($ComponentType) {
        "CPU" {
		            # Prefer exact-match benchmark-derived entries if present in DB.
		            # Try a few name variants because Win32_Processor.Name often includes tokens like "CPU" and "@ 2.30GHz",
		            # while benchmark datasets may not.
		            try {
		                $candidates = @()
		                if ($ComponentName) { $candidates += ("" + $ComponentName) }
		
		                # Remove common suffix tokens
		                try {
		                    $candidates += ((("" + $ComponentName) -replace '(?i)\bCPU\b|\bPROCESSOR\b', '').Trim())
		                } catch { }
		
		                # Remove anything after '@' (frequency)
		                try {
		                    $candidates += ((("" + $ComponentName) -split '@')[0].Trim())
		                } catch { }
		
		                # Both: remove tokens, then strip frequency
		                try {
		                    $tmp = (("" + $ComponentName) -replace '(?i)\bCPU\b|\bPROCESSOR\b', '')
		                    $candidates += (($tmp -split '@')[0].Trim())
		                } catch { }
		
		                foreach ($cand in ($candidates | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | Select-Object -Unique)) {
		                    $nk = Normalize-HardwareName -Name $cand
		                    if ($nk -and $script:__cpuExactMap.ContainsKey($nk)) {
		                        $e = $script:__cpuExactMap[$nk]
		                        $tier = try { $e.tier } catch { $null }
		                        if (-not $tier) { $tier = try { $e.Tier } catch { $null } }
		                        $score = try { $e.score } catch { $null }
		                        if ($null -eq $score) { $score = try { $e.Score } catch { $null } }
		                        $cat = try { $e.category } catch { $null }
		                        if (-not $cat) { $cat = try { $e.Category } catch { "CPU" } }
		                        $yr = try { $e.releaseYear } catch { $null }
		                        if ($null -eq $yr) { $yr = try { $e.EstimatedYear } catch { 2020 } }
		
				        # PowerShell 5.1 compatibility: avoid null-coalescing operator (??)
				        $tierOut = if ($tier) { $tier } else { "Unknown" }
				        $scoreOut = if ($null -ne $score) { [int]$score } else { 50 }
				        $catOut = if ($cat) { $cat } else { "CPU" }
				        $yrOut = if ($null -ne $yr) { [int]$yr } else { 2020 }
				        $bench = $null
				        $sources = $null
				        $specs = $null
				        try { $bench = $e.benchmarks } catch { $bench = $null }
				        try { $sources = $e.sources } catch { $sources = $null }
				        try { $specs = $e.specs } catch { $specs = $null }
				        return @{ Tier = $tierOut; Score = $scoreOut; Category = $catOut; EstimatedYear = $yrOut; Benchmarks = $bench; Sources = $sources; Specs = $specs }
		                    }
		                }
		            } catch { }

	            $matchedPattern = $null
	            if ($Database.cpus -and $Database.cpus.patterns) {
	                foreach ($pattern in $Database.cpus.patterns) {
	                    if ($ComponentName -imatch $pattern.pattern) {
	                        $result.Tier = $pattern.tier
	                        $result.Score = $pattern.score
	                        $result.Category = $pattern.category
	                        $result.EstimatedYear = $pattern.releaseYear
	                        $matchedPattern = $pattern
	                        break
	                    }
	                }
	            }

	            # Add granularity even when DB patterns are broad
	    $approxCpu = Get-ApproxCpuTier -Name ("" + $ComponentName)
	            if ($approxCpu) {
	                if ($result.Tier -eq "Unknown") {
	                    $result = $approxCpu
	                } else {
	                    # If the DB provides a min/max band, keep the score within it
	                    if ($matchedPattern -and $null -ne $matchedPattern.minScore -and $null -ne $matchedPattern.maxScore) {
	                        $minS = [int]$matchedPattern.minScore
	                        $maxS = [int]$matchedPattern.maxScore
	                        $result.Score = [int]([math]::Max($minS, [math]::Min($maxS, [int]$approxCpu.Score)))
	                    } else {
	                        $result.Score = [int]$approxCpu.Score
	                    }
	                }
	            }
        }
        "GPU" {
	            # Prefer exact-match benchmark-derived entries if present in DB.
	            try {
		                $nk = Normalize-HardwareName -Name ("" + $ComponentName)
	                if ($nk -and $script:__gpuExactMap.ContainsKey($nk)) {
	                    $e = $script:__gpuExactMap[$nk]
	                    $tier = try { $e.tier } catch { $null }
	                    if (-not $tier) { $tier = try { $e.Tier } catch { $null } }
	                    $score = try { $e.score } catch { $null }
	                    if ($null -eq $score) { $score = try { $e.Score } catch { $null } }
	                    $cat = try { $e.category } catch { $null }
	                    if (-not $cat) { $cat = try { $e.Category } catch { "GPU" } }
	                    $yr = try { $e.releaseYear } catch { $null }
	                    if ($null -eq $yr) { $yr = try { $e.EstimatedYear } catch { 2020 } }

				    # PowerShell 5.1 compatibility: avoid null-coalescing operator (??)
				    $tierOut = if ($tier) { $tier } else { "Unknown" }
				    $scoreOut = if ($null -ne $score) { [int]$score } else { 50 }
				    $catOut = if ($cat) { $cat } else { "GPU" }
				    $yrOut = if ($null -ne $yr) { [int]$yr } else { 2020 }
				    $bench = $null
				    $sources = $null
				    $specs = $null
				    try { $bench = $e.benchmarks } catch { $bench = $null }
				    try { $sources = $e.sources } catch { $sources = $null }
				    try { $specs = $e.specs } catch { $specs = $null }
				    return @{ Tier = $tierOut; Score = $scoreOut; Category = $catOut; EstimatedYear = $yrOut; Benchmarks = $bench; Sources = $sources; Specs = $specs }
	                }
	            } catch { }

	            $matched = $false
	            $matchedPattern = $null
	            # Backward compatibility: allow DB key to be either 'gpus' or legacy 'gpu'
	            $gpuDb = $null
	            if ($Database.gpus) { $gpuDb = $Database.gpus }
	            elseif ($Database.gpu) { $gpuDb = $Database.gpu }

	            if ($gpuDb -and $gpuDb.patterns) {
	                foreach ($pattern in $gpuDb.patterns) {
	                    if ($ComponentName -imatch $pattern.pattern) {
	                        $result.Tier = $pattern.tier
	                        $result.Score = $pattern.score
	                        $result.Category = $pattern.category
	                        $result.EstimatedYear = $pattern.releaseYear
	                        $matched = $true
	                        $matchedPattern = $pattern
	                        break
	                    }
	                }
	            }

	            # Add granularity to GPUs by parsing the model number
	            $approxGpu = Get-ApproxGpuTier -Name ("" + $ComponentName)
	            if ($approxGpu) {
	                if (-not $matched) {
	                    $result = $approxGpu
	                    $matched = $true
	                } else {
	                    # Keep within a small band around the DB score to preserve tier intent
	                    $low = [math]::Max(0, [int]$matchedPattern.score - 8)
	                    $high = [math]::Min(100, [int]$matchedPattern.score + 8)
	                    $result.Score = [int]([math]::Max($low, [math]::Min($high, [int]$approxGpu.Score)))
	                }
	            }
            # Fallback patterns for common GPUs not in database (inline detection)
            if (-not $matched) {
                $fallbackPatterns = @(
                    @{ Pattern = "RTX 5090|RTX 5080|RTX 4090|RTX 4080|Quadro RTX 8000|Quadro RTX 6000"; Tier = "Flagship"; Score = 98 },
                    @{ Pattern = "Quadro RTX 4000|Quadro RTX 5000|RTX 4070|RTX 5070|RTX A4000|RTX A4500"; Tier = "High Performance"; Score = 90 },
                    @{ Pattern = "Quadro RTX 3000|Quadro P5000|RTX 4060|RTX 3080|RTX 3070|RTX A2000"; Tier = "Performance"; Score = 80 },
                    @{ Pattern = "Quadro P4000|Quadro P3200|Quadro M5000|RTX 3060|RTX 3050"; Tier = "Mainstream"; Score = 70 },
                    @{ Pattern = "Quadro P2200|Quadro P2000|Quadro M4000|RTX 2080|RTX 2070|RTX 2060|GTX 1080|GTX 1070"; Tier = "Mid-Range"; Score = 60 },
                    @{ Pattern = "Quadro P1000|Quadro P620|Quadro P600|Quadro M2000|GTX 1660|GTX 1650|GTX 1060|GTX 1050"; Tier = "Entry Level"; Score = 45 },
                    @{ Pattern = "Quadro K|GTX 980|GTX 970|GTX 960|RX 560|RX 550"; Tier = "Budget"; Score = 35 },
                    @{ Pattern = "Intel.*Iris.*Xe|Intel.*Arc"; Tier = "Integrated Plus"; Score = 40 },
                    @{ Pattern = "Intel.*UHD|Intel.*HD|AMD.*Vega|AMD.*Graphics"; Tier = "Integrated"; Score = 25 }
                )
                foreach ($fb in $fallbackPatterns) {
                    if ($ComponentName -imatch $fb.Pattern) {
                        $result.Tier = $fb.Tier
                        $result.Score = $fb.Score
                        $result.Category = "GPU"
                        break
                    }
                }
            }
        }
        "RAM" {
	            # Prefer exact-match benchmark-derived entries if present in DB.
	            try {
	                $nk = Normalize-HardwareName -Name ("" + $ComponentName)
	                if ($nk -and $script:__ramExactMap.ContainsKey($nk)) {
	                    $e = $script:__ramExactMap[$nk]
	                    $tier = try { $e.tier } catch { $null }
	                    if (-not $tier) { $tier = try { $e.Tier } catch { $null } }
	                    $score = try { $e.score } catch { $null }
	                    if ($null -eq $score) { $score = try { $e.Score } catch { $null } }
	                    $cat = try { $e.category } catch { $null }
	                    if (-not $cat) { $cat = try { $e.Category } catch { "RAM" } }
	                    $yr = try { $e.releaseYear } catch { $null }
	                    if ($null -eq $yr) { $yr = try { $e.EstimatedYear } catch { 2020 } }

	                    $tierOut = if ($tier) { $tier } else { "Unknown" }
	                    $scoreOut = if ($null -ne $score) { [int]$score } else { 50 }
	                    $catOut = if ($cat) { $cat } else { "RAM" }
	                    $yrOut = if ($null -ne $yr) { [int]$yr } else { 2020 }

	                    $bench = $null
	                    $sources = $null
	                    $specs = $null
	                    try { $bench = $e.benchmarks } catch { $bench = $null }
	                    try { $sources = $e.sources } catch { $sources = $null }
	    	    	    try { $specs = $e.specs } catch { $specs = $null }
	    	    	    # PassMark RAM dataset stores DDR type as a top-level field (ddrType), not under specs
	    	    	    if (-not $specs) {
	    	    	        try {
	    	    	            $ddr = $null
	    	    	            try { $ddr = ("" + $e.ddrType).Trim() } catch { $ddr = $null }
	    	    	            if ($ddr) { $specs = [pscustomobject]@{ DDRType = $ddr } }
	    	    	        } catch { }
	    	    	    }
	                    return @{ Tier = $tierOut; Score = $scoreOut; Category = $catOut; EstimatedYear = $yrOut; Benchmarks = $bench; Sources = $sources; Specs = $specs }
	                }
	            } catch { }

	            # Fallback: PassMark RAM bins (DDR type + speed MHz). This is used when WMI names/part numbers
	            # don't match PassMark's marketing module names.
	            try {
	                if ($ComponentName -is [System.Collections.IDictionary]) {
	                    $ddr = $null
	                    $spd = 0
	                    try { $ddr = ("" + $ComponentName.DDRType).Trim() } catch { $ddr = $null }
	                    if (-not $ddr) { try { $ddr = ("" + $ComponentName.Type).Trim() } catch { $ddr = $null } }
	                    if ($ddr) { $ddr = $ddr.ToUpperInvariant() }
	
	                    try { $spd = [int](("" + $ComponentName.SpeedMHz) -replace '[^0-9]', '') } catch { $spd = 0 }
	                    if ($spd -le 0) { try { $spd = [int](("" + $ComponentName.Speed) -replace '[^0-9]', '') } catch { $spd = 0 } }
	
	                    if ($ddr -and $script:__ramBinsByType.ContainsKey($ddr)) {
	                        $bins = @($script:__ramBinsByType[$ddr])
	                        if ($bins -and $bins.Count -gt 0) {
	                            $best = $null
	
	                            if ($spd -gt 0) {
	                                foreach ($b in $bins) {
	                                    $bSpd = 0
	                                    try { $bSpd = [int]$b.speedMHz } catch { try { $bSpd = [int]$b.SpeedMHz } catch { $bSpd = 0 } }
	                                    if ($bSpd -le 0) { continue }
	                                    $diff = [math]::Abs($bSpd - $spd)
	                                    if (-not $best -or $diff -lt $best.diff) { $best = @{ item = $b; diff = $diff; speedMHz = $bSpd } }
	                                }
	
	                                if ($best -and $best.diff -le 600) {
	                                    $e = $best.item
	                                    $tier = try { $e.tier } catch { $null }
	                                    if (-not $tier) { $tier = try { $e.Tier } catch { $null } }
	                                    $score = try { $e.score } catch { $null }
	                                    if ($null -eq $score) { $score = try { $e.Score } catch { $null } }
	                                    $cat = try { $e.category } catch { $null }
	                                    if (-not $cat) { $cat = "PassMark RAM (bin)" }
	
	                                    $bench = $null; $sources = $null; $specs = $null
	                                    try { $bench = $e.benchmarks } catch { $bench = $null }
	                                    try { $sources = $e.sources } catch { $sources = $null }
	                                    try { $specs = $e.specs } catch { $specs = $null }
	                                    if (-not $specs) { $specs = [pscustomobject]@{ DDRType = $ddr; SpeedMHz = $best.speedMHz } }
	
	                                    $tierOut = if ($tier) { $tier } else { "Unknown" }
	                                    $scoreOut = if ($null -ne $score) { [int]$score } else { 50 }
	                                    return @{ Tier = $tierOut; Score = $scoreOut; Category = $cat; EstimatedYear = 2020; Benchmarks = $bench; Sources = $sources; Specs = $specs }
	                                }
	                            }

	                            # If speed is unknown/unreliable, choose the most representative bin by sample count.
	                            if ($spd -le 0) {
	                                $e = $bins | Sort-Object { try { [int]$_.sampleCount } catch { 0 } } -Descending | Select-Object -First 1
	                                if ($e) {
	                                    $tier = try { $e.tier } catch { $null }
	                                    if (-not $tier) { $tier = try { $e.Tier } catch { $null } }
	                                    $score = try { $e.score } catch { $null }
	                                    if ($null -eq $score) { $score = try { $e.Score } catch { $null } }
	                                    $cat = try { $e.category } catch { "PassMark RAM (bin)" }
	
	                                    $bench = $null; $sources = $null; $specs = $null
	                                    try { $bench = $e.benchmarks } catch { $bench = $null }
	                                    try { $sources = $e.sources } catch { $sources = $null }
	                                    try { $specs = $e.specs } catch { $specs = $null }
	                                    if (-not $specs) { $specs = [pscustomobject]@{ DDRType = $ddr } }
	
	                                    $tierOut = if ($tier) { $tier } else { "Unknown" }
	                                    $scoreOut = if ($null -ne $score) { [int]$score } else { 50 }
	                                    return @{ Tier = $tierOut; Score = $scoreOut; Category = $cat; EstimatedYear = 2020; Benchmarks = $bench; Sources = $sources; Specs = $specs }
	                                }
	                            }
	                        }
	                    }
	                }
	            } catch { }

	            # Allow both "16GB" and "16 GB" formats
	            if ($ComponentName -match "(\d+)\s*GB.*?(DDR\d+)") {
                $ramGB = [int]$matches[1]
                $ramType = $matches[2]

                if ($Database.ram -and $Database.ram.capacity) {
                    foreach ($tier in $Database.ram.capacity) {
                        $tierType = $tier.type
                        $tierMinGB = $tier.minGB

                        if (($tierType -eq "any" -or $ramType -eq $tierType -or ($tierType -eq "any" -and $ramGB -ge $tierMinGB)) -and $ramGB -ge $tierMinGB) {
                            $result.Tier = $tier.tier
                            $result.Score = $tier.score
                            $result.Category = $tier.category
                            break
                        }
                    }
                }
            }
        }
        "Storage" {
	            $modelName = $null
	            $legacyStr = $null
	            try {
	                if ($ComponentName -is [System.Collections.IDictionary]) {
	                    try { $modelName = ("" + $ComponentName.Model).Trim() } catch { $modelName = $null }
	                    try { $legacyStr = ("" + $ComponentName.LegacyString).Trim() } catch { $legacyStr = $null }
	                } else {
	                    $modelName = ("" + $ComponentName)
	                }
	            } catch { }

	            # Prefer PassMark DiskMark exact entries if present in DB
	            try {
	                $nk = Normalize-HardwareName -Name $modelName
	                if ($nk -and $script:__storageExactMap.ContainsKey($nk)) {
	                    $e = $script:__storageExactMap[$nk]
	                    $tier = try { $e.tier } catch { $null }
	                    if (-not $tier) { $tier = try { $e.Tier } catch { $null } }
	                    $score = try { $e.score } catch { $null }
	                    if ($null -eq $score) { $score = try { $e.Score } catch { $null } }
	                    $cat = try { $e.category } catch { $null }
	                    if (-not $cat) { $cat = try { $e.Category } catch { "Storage" } }
	                    $yr = try { $e.releaseYear } catch { $null }
	                    if ($null -eq $yr) { $yr = try { $e.EstimatedYear } catch { 2020 } }

	                    $tierOut = if ($tier) { $tier } else { "Unknown" }
	                    $scoreOut = if ($null -ne $score) { [int]$score } else { 50 }
	                    $catOut = if ($cat) { $cat } else { "Storage" }
	                    $yrOut = if ($null -ne $yr) { [int]$yr } else { 2020 }

	                    $bench = $null
	                    $sources = $null
	                    $specs = $null
	                    try { $bench = $e.benchmarks } catch { $bench = $null }
	                    try { $sources = $e.sources } catch { $sources = $null }
	    	    	    try { $specs = $e.specs } catch { $specs = $null }
	    	    	    # PassMark Storage dataset stores basic fields at top-level (type/size), not under specs
	    	    	    if (-not $specs) {
	    	    	        try {
	    	    	            $stType = $null
	    	    	            $stSize = $null
	    	    	            try { $stType = ("" + $e.type).Trim() } catch { $stType = $null }
	    	    	            try { $stSize = ("" + $e.size).Trim() } catch { $stSize = $null }
	    	    	            if ($stType -or $stSize) { $specs = [pscustomobject]@{ Type = $stType; Size = $stSize } }
	    	    	        } catch { }
	    	    	    }
	                    return @{ Tier = $tierOut; Score = $scoreOut; Category = $catOut; EstimatedYear = $yrOut; Benchmarks = $bench; Sources = $sources; Specs = $specs }
	                }
	            } catch { }

	            # Fallback: try vendor/capacity-agnostic key (helps WMI strings like "PM981a NVMe SAMSUNG 2048GB")
	            try {
	                $ak = Normalize-StorageMatchKey -Name $modelName
	                if ($ak -and $script:__storageExactMap.ContainsKey($ak)) {
	                    $e = $script:__storageExactMap[$ak]
	                    $tier = try { $e.tier } catch { $null }
	                    if (-not $tier) { $tier = try { $e.Tier } catch { $null } }
	                    $score = try { $e.score } catch { $null }
	                    if ($null -eq $score) { $score = try { $e.Score } catch { $null } }
	                    $cat = try { $e.category } catch { $null }
	                    if (-not $cat) { $cat = try { $e.Category } catch { "Storage" } }
	                    $yr = try { $e.releaseYear } catch { $null }
	                    if ($null -eq $yr) { $yr = try { $e.EstimatedYear } catch { 2020 } }

	                    $tierOut = if ($tier) { $tier } else { "Unknown" }
	                    $scoreOut = if ($null -ne $score) { [int]$score } else { 50 }
	                    $catOut = if ($cat) { $cat } else { "Storage" }
	                    $yrOut = if ($null -ne $yr) { [int]$yr } else { 2020 }

	                    $bench = $null
	                    $sources = $null
	                    $specs = $null
	                    try { $bench = $e.benchmarks } catch { $bench = $null }
	                    try { $sources = $e.sources } catch { $sources = $null }
	    	    	    try { $specs = $e.specs } catch { $specs = $null }
	    	    	    # PassMark Storage dataset stores basic fields at top-level (type/size), not under specs
	    	    	    if (-not $specs) {
	    	    	        try {
	    	    	            $stType = $null
	    	    	            $stSize = $null
	    	    	            try { $stType = ("" + $e.type).Trim() } catch { $stType = $null }
	    	    	            try { $stSize = ("" + $e.size).Trim() } catch { $stSize = $null }
	    	    	            if ($stType -or $stSize) { $specs = [pscustomobject]@{ Type = $stType; Size = $stSize } }
	    	    	        } catch { }
	    	    	    }
	                    return @{ Tier = $tierOut; Score = $scoreOut; Category = $catOut; EstimatedYear = $yrOut; Benchmarks = $bench; Sources = $sources; Specs = $specs }
	                }
	            } catch { }

	            # Fallback: legacy speed/capacity string: "GB|Type|Speed"
	            if ([string]::IsNullOrWhiteSpace($legacyStr)) { $legacyStr = ("" + $ComponentName) }
	            if ($legacyStr -match "(\d+)\|(.*?)\|(\d+)") {
	                $capacity = [int]$matches[1]
	                $type = $matches[2]
		    	        $speed = [int]$matches[3]

		    	        # If the quick IO test under-reports (or fails), use the detected bus/media type
		    	        # to avoid classifying NVMe as SATA SSD/HDD. This keeps tiers sane on Win10/11.
		    	        if ($type -match "(?i)NVMe" -and $speed -lt 1500) { $speed = 2000 }
		    	        elseif ($type -match "(?i)SSD" -and $speed -lt 450) { $speed = 500 }
		    	        elseif ($type -match "(?i)HDD" -and $speed -lt 90) { $speed = 100 }

	                if ($Database.storage -and $Database.storage.speed) {
	                    foreach ($tier in $Database.storage.speed) {
	                        if ($speed -ge $tier.minSpeed) {
	                            $result.Tier = $tier.tier
	                            $result.Score = $tier.score
	                            $result.Category = $tier.category
	                            break
	                        }
	                    }
	                }
	            }
        }
        "Display" {
            if ($ComponentName -match "(\d+)x(\d+)@(\d+)") {
                $width = [int]$matches[1]
                $hz = [int]$matches[3]

                $resScore = 50
                $hzScore = 50

                if ($Database.display) {
                    if ($Database.display.resolution) {
                        foreach ($tier in $Database.display.resolution) {
                            if ($width -ge $tier.minWidth) {
                                $resScore = $tier.score
                                $result.Tier = $tier.tier
                                break
                            }
                        }
                    }

                    if ($Database.display.refreshRate) {
                        foreach ($tier in $Database.display.refreshRate) {
                            if ($hz -ge $tier.minHz) {
                                $hzScore = $tier.score
                                break
                            }
                        }
                    }
                }

                $result.Score = [math]::Round(($resScore * 0.7 + $hzScore * 0.3), 0)
                $result.Category = "$($matches[1])x$($matches[2]) @ $($matches[3])Hz"
            }
        }
    }

    return $result
}

function Get-UseCaseRecommendations {
    param([int]$PerformanceScore, [object]$Database)

    $recommendations = @{
        Suitable = @()
        Limited = @()
        NotRecommended = @()
    }

    if (-not $Database -or -not $Database.useCases -or -not $Database.useCases.performance_ranges) {
        return $recommendations
    }

    foreach ($range in $Database.useCases.performance_ranges) {
        if ($PerformanceScore -ge $range.minScore -and $PerformanceScore -le $range.maxScore) {
            $recommendations.Suitable = $range.suitable
            $recommendations.Limited = $range.limited
            $recommendations.NotRecommended = $range.notRecommended
            $recommendations.Tier = $range.tier
            break
        }
    }

    return $recommendations
}

function Get-UpgradeRecommendations {
    param([hashtable]$CurrentSpecs, [object]$Database)

    $upgrades = @()

    if (-not $Database -or -not $Database.upgrades) {
        return $upgrades
    }

    if ($CurrentSpecs.RAM -le 4) {
        $upgrades += @{
            Component = "RAM"
            Current = "$($CurrentSpecs.RAM)GB"
            Recommended = "16GB"
            Cost = "$50-80"
            Impact = "VERY HIGH"
            PerformanceGain = 60
            Priority = 1
            Description = "Critical upgrade - 4GB is insufficient for modern Windows."
        }
    }
    elseif ($CurrentSpecs.RAM -eq 8) {
        $upgrades += @{
            Component = "RAM"
            Current = "8GB"
            Recommended = "16GB"
            Cost = "$30-50"
            Impact = "HIGH"
            PerformanceGain = 25
            Priority = 2
            Description = "Strongly recommended - 16GB is the standard for 2025."
        }
    }

		$storageType = (($CurrentSpecs.StorageType -as [string]) + "").Trim()
		$hasSSD = $false
		try {
			if ($CurrentSpecs -and $CurrentSpecs.ContainsKey('HasSSD')) { $hasSSD = [bool]$CurrentSpecs.HasSSD }
		} catch { $hasSSD = $false }

		# Only recommend buying an SSD if there isn't already an SSD/NVMe present.
		if ($storageType -match '(?i)\bHDD\b' -and -not $hasSSD) {
        $upgrades += @{
            Component = "Storage"
            Current = "HDD"
            Recommended = "512GB SSD"
            Cost = "$35-60"
            Impact = "VERY HIGH"
            PerformanceGain = 200
            Priority = 1
            Description = "Most impactful upgrade! Boot time drops from minutes to seconds."
        }
    }

    if ($CurrentSpecs.BatteryHealth -gt 0 -and $CurrentSpecs.BatteryHealth -lt 50) {
        $upgrades += @{
            Component = "Battery"
            Current = "$($CurrentSpecs.BatteryHealth)% Health"
            Recommended = "New Battery"
            Cost = "$40-120"
            Impact = "HIGH"
            PerformanceGain = 100
            Priority = 2
            Description = "Battery health below 50% means very poor runtime."
        }
    }

    if ($CurrentSpecs.CPUAge -gt 7 -or $CurrentSpecs.PerformanceScore -lt 40) {
        $upgrades += @{
            Component = "Full Laptop"
            Current = "Current System"
            Recommended = "New Laptop"
            Cost = "$600-900"
            Impact = "VERY HIGH"
            PerformanceGain = 150
            Priority = 1
            Description = "System is significantly outdated. New mid-range laptop would provide substantially better performance."
        }
    }

    $upgrades = $upgrades | Sort-Object Priority
    return $upgrades
}

function Test-CPUBenchmark {
    try {
        $stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
        $iterations = 0

        while ($stopwatch.ElapsedMilliseconds -lt 3000) {
            $temp = [math]::Sqrt([math]::Pow((Get-Random -Maximum 10000), 2))
            $temp = [math]::Log($temp + 1)
            $temp = [math]::Exp([math]::Log($temp + 1))
            $iterations++
        }

        $stopwatch.Stop()
        $opsPerSecond = [math]::Round($iterations / ($stopwatch.ElapsedMilliseconds / 1000), 0)
        $benchmarkScore = [math]::Min(100, [math]::Round(($opsPerSecond / 1000), 0))

        return @{
            OpsPerSecond = $opsPerSecond
            Score = $benchmarkScore
        }
    }
    catch {
        return @{ OpsPerSecond = 0; Score = 0 }
    }
}

function Get-CPUTemperatureReading {
    # Best-effort temperature reading across common Windows sensor sources.
    # Returns: @{ Celsius = <double|null>; Source = <string> }
    $result = @{ Celsius = $null; Source = "N/A" }

    # Make sure WMI is running (many sensor paths depend on it)
    try { $null = Ensure-WmiServiceRunning } catch { }

    # 1) ACPI thermal zone (common on laptops; often missing on desktops)
    try {
        $thermal = Get-CimInstance -Namespace root\wmi -ClassName MSAcpi_ThermalZoneTemperature -ErrorAction Stop | Select-Object -First 1
        if ($thermal -and $thermal.CurrentTemperature) {
            $c = [math]::Round((([double]$thermal.CurrentTemperature / 10.0) - 273.15), 1)
            if ($c -gt -30 -and $c -lt 150) {
                $result.Celsius = $c
                $result.Source = "ACPI (MSAcpi_ThermalZoneTemperature)"
                return $result
            }
        }
    } catch { }

    # 2) Performance counter "Thermal Zone Information" (may report Kelvin)
    try {
        $ctr = Get-Counter "\\Thermal Zone Information(*)\\Temperature" -ErrorAction Stop
        $samples = @($ctr.CounterSamples) | Where-Object { $_ -and $_.CookedValue -ne $null }
        if ($samples.Count -gt 0) {
            $v = [double]($samples | Select-Object -First 1).CookedValue
            $c = if ($v -gt 200) { [math]::Round(($v - 273.15), 1) } else { [math]::Round($v, 1) }
            if ($c -gt -30 -and $c -lt 150) {
                $result.Celsius = $c
                $result.Source = "PerfCounter (Thermal Zone Information)"
                return $result
            }
        }
    } catch { }

    # 3) LibreHardwareMonitor WMI provider (if installed & running)
    try {
        $sensors = @(Get-CimInstance -Namespace root\LibreHardwareMonitor -ClassName Sensor -ErrorAction Stop |
            Where-Object { $_.SensorType -eq "Temperature" -and $_.Value -ne $null })
        if ($sensors.Count -gt 0) {
            $preferred = $sensors | Where-Object {
                ($_.Name -match "(?i)CPU\s*Package|Package|Tdie|CPU\s*Core") -or ($_.Identifier -match "(?i)/cpu/")
            }
            $best = @($preferred)[0]
            if (-not $best) {
                $cpuLike = $sensors | Where-Object { $_.Name -match "(?i)CPU" -or $_.Identifier -match "(?i)/cpu/" }
                $best = $cpuLike | Sort-Object -Property Value -Descending | Select-Object -First 1
            }
            if (-not $best) { $best = $sensors | Sort-Object -Property Value -Descending | Select-Object -First 1 }
            $c = [math]::Round([double]$best.Value, 1)
            if ($c -gt -30 -and $c -lt 150) {
                $result.Celsius = $c
                $result.Source = "LibreHardwareMonitor WMI ($($best.Name))"
                return $result
            }
        }
    } catch { }

    # 4) OpenHardwareMonitor WMI provider (if installed & running)
    try {
        $sensors = @(Get-CimInstance -Namespace root\OpenHardwareMonitor -ClassName Sensor -ErrorAction Stop |
            Where-Object { $_.SensorType -eq "Temperature" -and $_.Value -ne $null })
        if ($sensors.Count -gt 0) {
            $preferred = $sensors | Where-Object {
                ($_.Name -match "(?i)CPU\s*Package|Package|Tdie|CPU\s*Core") -or ($_.Identifier -match "(?i)/cpu/")
            }
            $best = @($preferred)[0]
            if (-not $best) {
                $cpuLike = $sensors | Where-Object { $_.Name -match "(?i)CPU" -or $_.Identifier -match "(?i)/cpu/" }
                $best = $cpuLike | Sort-Object -Property Value -Descending | Select-Object -First 1
            }
            if (-not $best) { $best = $sensors | Sort-Object -Property Value -Descending | Select-Object -First 1 }
            $c = [math]::Round([double]$best.Value, 1)
            if ($c -gt -30 -and $c -lt 150) {
                $result.Celsius = $c
                $result.Source = "OpenHardwareMonitor WMI ($($best.Name))"
                return $result
            }
        }
    } catch { }

    return $result
}

function Test-CPUTemperature {
    $tempBefore = 0
    $tempAfter = 0
    $tempMin = 999
    $tempMax = 0
    $tempAvg = 0
    $tempDelta = 0
    $temperatures = @()

    try {
	        # Get temperature before stress (best-effort)
	        $before = Get-CPUTemperatureReading
	        if (-not $before -or $null -eq $before.Celsius) {
	            return @{
	                Before = 0
	                After = 0
	                Min = 0
	                Max = 0
	                Avg = 0
	                Delta = 0
	                Tested = $false
	                HasHeatingIssues = $false
	                HeatingAssessment = "Unable to Test"
	                HeatingIssues = @()
	                CoolingRecommendations = @("Temperature sensor not available")
	            }
	        }
	        $tempBefore = [double]$before.Celsius
	        $tempMin = $tempBefore
	        $tempMax = $tempBefore

        # Run stress test for 15 seconds and collect temperatures
        $stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
        $lastCheck = 0

        while ($stopwatch.ElapsedMilliseconds -lt 5000) {
            # Intensive calculation
            $null = [math]::Sqrt([math]::Pow((Get-Random -Maximum 100000), 2))
            $null = [math]::Log([math]::Exp((Get-Random -Maximum 100) + 1))

	            # Check temperature every 2 seconds
            if ($stopwatch.ElapsedMilliseconds - $lastCheck -ge 2000) {
	                $r = Get-CPUTemperatureReading
	                if ($r -and $null -ne $r.Celsius) {
	                    $currentTemp = [double]$r.Celsius
	                    $temperatures += $currentTemp
	                    if ($currentTemp -lt $tempMin) { $tempMin = $currentTemp }
	                    if ($currentTemp -gt $tempMax) { $tempMax = $currentTemp }
	                }
                $lastCheck = $stopwatch.ElapsedMilliseconds
            }
        }

        $stopwatch.Stop()
        Start-Sleep -Seconds 2  # Let temp stabilize

	        # Get temperature after stress
	        $after = Get-CPUTemperatureReading
	        if ($after -and $null -ne $after.Celsius) {
	            $tempAfter = [double]$after.Celsius
	        } else {
	            $tempAfter = $tempBefore
	        }

        # Calculate average
        if ($temperatures.Count -gt 0) {
            $tempAvg = [math]::Round(($temperatures | Measure-Object -Average).Average, 1)
        }

        $tempDelta = [math]::Round($tempAfter - $tempBefore, 1)

        # Assess heating issues
        $heatingIssues = @()
        $coolingRecommendations = @()
        $heatingAssessment = "No Issues"
        $hasHeatingIssues = $false

        # Critical issues (temperature > 95°C)
        if ($tempMax -gt 95) {
            $hasHeatingIssues = $true
            $heatingAssessment = "Critical Issues"
            $heatingIssues += "Maximum temperature reached $tempMax°C (Critical - above 95°C)"
            $heatingIssues += "CPU may throttle performance to prevent damage"
            $coolingRecommendations += "[URGENT] Clean laptop vents and fans immediately"
            $coolingRecommendations += "[URGENT] Consider professional thermal paste replacement"
            $coolingRecommendations += "[URGENT] Use laptop on hard, flat surface for better airflow"
        }
        # Moderate issues (temperature > 85°C or avg > 75°C)
        elseif ($tempMax -gt 85 -or $tempAvg -gt 75) {
            $hasHeatingIssues = $true
            $heatingAssessment = "Moderate Issues"
            if ($tempMax -gt 85) {
                $heatingIssues += "Maximum temperature reached $tempMax°C (High - above 85°C)"
            }
            if ($tempAvg -gt 75) {
                $heatingIssues += "Average temperature during stress: $tempAvg°C (High - above 75°C)"
            }
            $heatingIssues += "Cooling system may be insufficient or blocked"
            $coolingRecommendations += "Clean laptop vents and fans"
            $coolingRecommendations += "Ensure laptop is on hard, flat surface"
            $coolingRecommendations += "Consider using laptop cooling pad"
            $coolingRecommendations += "Check if thermal paste needs replacement"
        }
        # Minor issues (rapid temperature rise or moderately high temps)
        elseif ($tempDelta -gt 25 -or ($tempDelta -gt 20 -and $tempMax -gt 80)) {
            $hasHeatingIssues = $true
            $heatingAssessment = "Minor Issues"
            if ($tempDelta -gt 25) {
                $heatingIssues += "Rapid temperature increase: $tempDelta°C in 15 seconds"
            }
            if ($tempMax -gt 80) {
                $heatingIssues += "Maximum temperature reached $tempMax°C (Slightly high)"
            }
            $coolingRecommendations += "Monitor temperatures during heavy use"
            $coolingRecommendations += "Consider cleaning laptop vents"
            $coolingRecommendations += "Ensure good airflow around laptop"
        }
        # Good cooling performance
        elseif ($tempMax -lt 75 -and $tempDelta -lt 20) {
            $heatingAssessment = "Excellent"
            $coolingRecommendations += "Cooling system is performing well"
            $coolingRecommendations += "Temperature stayed within safe limits"
            $coolingRecommendations += "Continue regular maintenance to keep performance optimal"
        }
        # Acceptable performance
        else {
            $heatingAssessment = "Good"
            $coolingRecommendations += "Cooling system is functioning adequately"
            $coolingRecommendations += "Regular maintenance recommended to maintain performance"
        }

        return @{
            Before = $tempBefore
            After = $tempAfter
            Min = $tempMin
            Max = $tempMax
            Avg = $tempAvg
            Delta = $tempDelta
            Tested = $true
            HasHeatingIssues = $hasHeatingIssues
            HeatingAssessment = $heatingAssessment
            HeatingIssues = $heatingIssues
            CoolingRecommendations = $coolingRecommendations
        }
    }
    catch {
        return @{
            Before = 0
            After = 0
            Min = 0
            Max = 0
            Avg = 0
            Delta = 0
            Tested = $false
            HasHeatingIssues = $false
            HeatingAssessment = "Unable to Test"
            HeatingIssues = @()
            CoolingRecommendations = @("Temperature sensor not available")
        }
    }
}

#endregion

#region Battery Detection (keeping existing function)
function Get-BatteryInfo {
    $batteryInfo = @{
        Detected = $false
        Health = 0
        CurrentCharge = 0
        DesignCapacity = 0
        FullChargeCapacity = 0
        Debug = @()  # non-verbose diagnostics (also available via -Verbose)
        Status = "Not Detected"
        BackupTime = "N/A"
        CycleCount = "N/A"
        Manufacturer = "N/A"
        Chemistry = "N/A"
        Voltage = "N/A"
        CurrentRate = "N/A"
        RemainingCapacity = "N/A"
    }

    # Helper: normalize WMI values (handles arrays/multiple batteries)
    function _Get-IntSum($values) {
        $vals = @($values) | Where-Object { $_ -ne $null }
        if (-not $vals -or $vals.Count -eq 0) { return 0 }
        $nums = @()
        foreach ($v in $vals) {
            try {
                if ($v -is [string]) {
                    $digits = ($v -replace '[^0-9]', '')
                    if ($digits) { $nums += [int]$digits }
                } else {
                    $nums += [int]$v
                }
            } catch {
                # ignore
            }
        }
        if (-not $nums -or $nums.Count -eq 0) { return 0 }
        return [int](($nums | Measure-Object -Sum).Sum)
    }

    $batteries = @(Get-CimInstance Win32_Battery -ErrorAction SilentlyContinue)
    if ($batteries -and $batteries.Count -gt 0) {
        $batteryInfo.Detected = $true
        $b0 = $batteries | Select-Object -First 1
        $batteryInfo.CurrentCharge = $b0.EstimatedChargeRemaining
        $batteryInfo.Chemistry = switch ($b0.Chemistry) {
            1 { "Other" }; 2 { "Unknown" }; 3 { "Lead Acid" }
            4 { "Nickel Cadmium" }; 5 { "Nickel Metal Hydride" }
            6 { "Lithium Ion" }; 7 { "Zinc Air" }
            8 { "Lithium Polymer" }
	        default { "Code $($b0.Chemistry)" }
        }

        $batteryInfo.Status = switch ($b0.BatteryStatus) {
            1 { "Discharging" }; 2 { "On AC Power" }; 3 { "Fully Charged" }
            4 { "Low" }; 5 { "Critical" }; 6 { "Charging" }
            7 { "Charging and High" }; 8 { "Charging and Low" }
            9 { "Charging and Critical" }; 10 { "Undefined" }
            11 { "Partially Charged" }
            default { "Unknown" }
        }

        # Some systems populate capacities here; normalize if present (and don't clobber later sources)
        $winDesign = _Get-IntSum (@($batteries | ForEach-Object { $_.DesignCapacity }))
        if ($batteryInfo.DesignCapacity -le 0 -and $winDesign -gt 0) {
            $batteryInfo.DesignCapacity = $winDesign
            $batteryInfo.Debug += "DesignCapacity from Win32_Battery = $winDesign (units vary by vendor)"
        }
        $winFull = _Get-IntSum (@($batteries | ForEach-Object { $_.FullChargeCapacity }))
        if ($batteryInfo.FullChargeCapacity -le 0 -and $winFull -gt 0) {
            $batteryInfo.FullChargeCapacity = $winFull
            $batteryInfo.Debug += "FullChargeCapacity from Win32_Battery = $winFull (units vary by vendor)"
        }
    }

    try {
        $battStatus = @(Get-CimInstance -Namespace root\wmi -ClassName BatteryFullChargedCapacity -ErrorAction Stop)
        if ($battStatus -and $battStatus.Count -gt 0) {
            $fullVals = @($battStatus | ForEach-Object { $_.FullChargedCapacity })
            $sumFull = _Get-IntSum $fullVals
            if ($sumFull -gt 0) {
                if ($batteryInfo.FullChargeCapacity -le 0 -or $sumFull -gt $batteryInfo.FullChargeCapacity) {
                    $batteryInfo.FullChargeCapacity = $sumFull
                }
                $batteryInfo.Debug += "FullChargeCapacity from WMI(root\\wmi:BatteryFullChargedCapacity) = $sumFull mWh"
                Write-Verbose "[Battery] FullChargeCapacity (WMI BatteryFullChargedCapacity) = $sumFull mWh"
            } else {
                $batteryInfo.Debug += "WMI BatteryFullChargedCapacity returned 0/empty"
            }
        }
    } catch {
        $batteryInfo.Debug += "WMI BatteryFullChargedCapacity query failed: $($_.Exception.Message)"
    }

    try {
        $battStatusDetailed = @(Get-CimInstance -Namespace root\wmi -ClassName BatteryStatus -ErrorAction Stop)
        if ($battStatusDetailed -and $battStatusDetailed.Count -gt 0) {
            $bs = $battStatusDetailed | Select-Object -First 1
            if ($bs.Voltage) {
                $batteryInfo.Voltage = "$([math]::Round($bs.Voltage / 1000, 1)) V"
            }
            if ($bs.RemainingCapacity) {
                $batteryInfo.RemainingCapacity = "$([math]::Round($bs.RemainingCapacity / 1000, 1)) Wh"
            }
            if ($bs.ChargeRate) {
                $watts = [math]::Abs([math]::Round($bs.ChargeRate / 1000, 1))
                $batteryInfo.CurrentRate = "$watts W"
            }
        }
    } catch {
        $batteryInfo.Debug += "WMI BatteryStatus query failed: $($_.Exception.Message)"
    }

    try {
        $battStatic = @(Get-CimInstance -Namespace root\wmi -ClassName BatteryStaticData -ErrorAction Stop)
        if ($battStatic -and $battStatic.Count -gt 0) {
            $designVals = @($battStatic | ForEach-Object { $_.DesignedCapacity })
            $sumDesign = _Get-IntSum $designVals
            if ($sumDesign -gt 0) {
                if ($batteryInfo.DesignCapacity -le 0 -or $sumDesign -gt $batteryInfo.DesignCapacity) {
                    $batteryInfo.DesignCapacity = $sumDesign
                }
                $batteryInfo.Debug += "DesignCapacity from WMI(root\\wmi:BatteryStaticData) = $sumDesign mWh"
                Write-Verbose "[Battery] DesignCapacity (WMI BatteryStaticData) = $sumDesign mWh"
            } else {
                $batteryInfo.Debug += "WMI BatteryStaticData returned 0/empty DesignedCapacity"
            }

            # Manufacturer name (take first non-empty)
            foreach ($bs in $battStatic) {
                if ($bs.ManufactureName) {
                    try {
                        $m = [System.Text.Encoding]::Unicode.GetString($bs.ManufactureName).Trim([char]0)
                        if ($m) { $batteryInfo.Manufacturer = $m; break }
                    } catch {}
                }
            }
        }
    } catch {
        $batteryInfo.Debug += "WMI BatteryStaticData query failed: $($_.Exception.Message)"
    }

    # Only run powercfg fallback if we still need capacities or cycle count
    if (($batteryInfo.DesignCapacity -le 0) -or ($batteryInfo.FullChargeCapacity -le 0) -or ($batteryInfo.CycleCount -eq "N/A")) {
    try {
        $tempReport = Join-Path $env:TEMP "battery-report-temp.html"
        $pcfgOut = (powercfg /batteryreport /output $tempReport /duration 1 2>&1 | Out-String)

        if (Test-Path $tempReport) {
            $reportContent = Get-Content $tempReport -Raw

            # Strip tags to make matching robust across minor HTML changes and locales with separators
            $reportText = ($reportContent -replace '<[^>]+>', ' ')
            $reportText = ($reportText -replace '\s+', ' ').Trim()

            if ($reportText -match 'DESIGN\s+CAPACITY\s+([0-9][0-9,\.\s]+)\s*mWh') {
                $digits = ($matches[1] -replace '[^0-9]', '')
                if ($digits) {
                    if ($batteryInfo.DesignCapacity -le 0) {
                        $batteryInfo.DesignCapacity = [int]$digits
                    }
                    $batteryInfo.Debug += "DesignCapacity from powercfg batteryreport = $($batteryInfo.DesignCapacity) mWh"
                    Write-Verbose "[Battery] DesignCapacity (powercfg) = $($batteryInfo.DesignCapacity) mWh"
                }
            } else {
                $batteryInfo.Debug += "powercfg batteryreport did not match DESIGN CAPACITY"
            }

            if ($reportText -match 'FULL\s+CHARGE\s+CAPACITY\s+([0-9][0-9,\.\s]+)\s*mWh') {
                $digits = ($matches[1] -replace '[^0-9]', '')
                if ($digits) {
                    if ($batteryInfo.FullChargeCapacity -le 0) {
                        $batteryInfo.FullChargeCapacity = [int]$digits
                    }
                    $batteryInfo.Debug += "FullChargeCapacity from powercfg batteryreport = $($batteryInfo.FullChargeCapacity) mWh"
                    Write-Verbose "[Battery] FullChargeCapacity (powercfg) = $($batteryInfo.FullChargeCapacity) mWh"
                }
            } else {
                $batteryInfo.Debug += "powercfg batteryreport did not match FULL CHARGE CAPACITY"
            }

            if ($reportText -match 'CYCLE\s+COUNT\s+(\d+)') {
                $batteryInfo.CycleCount = $matches[1]
            }

            Remove-Item $tempReport -Force -ErrorAction SilentlyContinue
        } else {
            if ($pcfgOut) {
                $batteryInfo.Debug += "powercfg batteryreport failed or did not write file: $($pcfgOut.Trim())"
            } else {
                $batteryInfo.Debug += "powercfg batteryreport did not create output file"
            }
        }
    } catch {
        $batteryInfo.Debug += "powercfg batteryreport parsing failed: $($_.Exception.Message)"
    }
    } else {
        $batteryInfo.Debug += "powercfg batteryreport skipped (capacities already detected)"
    }

    if ($batteryInfo.FullChargeCapacity -gt 0 -and $batteryInfo.DesignCapacity -gt 0) {
        $batteryInfo.Health = [math]::Round(($batteryInfo.FullChargeCapacity / $batteryInfo.DesignCapacity) * 100, 1)
        if ($batteryInfo.Health -gt 100) {
            $batteryInfo.Health = 100
        }
        $batteryInfo.Debug += "Battery Health computed = $($batteryInfo.Health)%"
        Write-Verbose "[Battery] Health = $($batteryInfo.Health)% (Full=$($batteryInfo.FullChargeCapacity), Design=$($batteryInfo.DesignCapacity))"
    } elseif ($batteryInfo.Detected) {
        $batteryInfo.Debug += "Battery detected but capacities missing/0 (Full=$($batteryInfo.FullChargeCapacity), Design=$($batteryInfo.DesignCapacity))"
    }

    return $batteryInfo
}

function Get-ChargerInfo {
    $chargerInfo = @{
        Detected = $false
        Manufacturer = "N/A"
        Voltage = "N/A"
        Current = "N/A"
        Wattage = "N/A"
        Status = "Not Detected"
    }

    try {
        $battery = Get-CimInstance Win32_Battery -ErrorAction SilentlyContinue
        if ($battery) {
            $batteryStatus = $battery.BatteryStatus
            if ($batteryStatus -eq 2 -or $batteryStatus -eq 6 -or $batteryStatus -eq 7 -or $batteryStatus -eq 3) {
                $chargerInfo.Detected = $true
                $chargerInfo.Status = "Connected"
            } else {
                $chargerInfo.Status = "Not Connected"
            }
        }

        $portableBattery = Get-CimInstance -Namespace root\wmi -ClassName BatteryStatus -ErrorAction SilentlyContinue
        if ($portableBattery -and $portableBattery.ChargeRate -gt 0) {
            $chargerInfo.Detected = $true
            $watts = [math]::Round($portableBattery.ChargeRate / 1000, 1)
            $chargerInfo.Wattage = "$watts W"

            if ($portableBattery.Voltage) {
                $volts = [math]::Round($portableBattery.Voltage / 1000, 1)
                $chargerInfo.Voltage = "$volts V"

                if ($volts -gt 0) {
                    $amps = [math]::Round($watts / $volts, 2)
                    $chargerInfo.Current = "$amps A"
                }
            }
        }
    } catch {}

    return $chargerInfo
}

function Test-AdapterHealth {
    $adapterTest = @{
        Connected = $false
        Voltage = @{
            Current = 0
            Min = 0
            Max = 0
            Avg = 0
            Stability = "Unknown"
        }
        Current = @{
            Current = 0
            Min = 0
            Max = 0
            Avg = 0
        }
        Power = @{
            Current = 0
            Min = 0
            Max = 0
            Avg = 0
            EstimatedRating = "Unknown"
        }
        ChargingRate = @{
            Current = 0
            Min = 0
            Max = 0
            Avg = 0
            IsCharging = $false
        }
        BatteryLevel = @{
            Start = 0
            End = 0
            Delta = 0
        }
        Health = "Unknown"
        Issues = @()
        Recommendations = @()
        Tested = $false
    }

    try {
        # Check if adapter is connected
        $battery = Get-CimInstance Win32_Battery -ErrorAction SilentlyContinue
        if ($battery) {
            $batteryStatus = $battery.BatteryStatus
            $adapterTest.Connected = ($batteryStatus -eq 2 -or $batteryStatus -eq 6 -or $batteryStatus -eq 7 -or $batteryStatus -eq 3)

            if (-not $adapterTest.Connected) {
                $adapterTest.Health = "Not Connected"
                $adapterTest.Recommendations += "Connect AC adapter to perform comprehensive testing"
                return $adapterTest
            }

            # Initialize tracking arrays
            $voltages = @()
            $currents = @()
            $powers = @()
            $chargeRates = @()

            # Get initial battery level
            $batteryStart = Get-CimInstance -Namespace root\wmi -ClassName BatteryStatus -ErrorAction SilentlyContinue | Select-Object -First 1
            if ($batteryStart -and $batteryStart.RemainingCapacity -and $batteryStart.MaxCapacity) {
                $adapterTest.BatteryLevel.Start = [math]::Round((([double]$batteryStart.RemainingCapacity / [double]$batteryStart.MaxCapacity) * 100), 1)
            }

            # Monitor for 10 seconds
            $stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
            $lastCheck = 0

            while ($stopwatch.ElapsedMilliseconds -lt 10000) {
                # Sample every second
                if ($stopwatch.ElapsedMilliseconds - $lastCheck -ge 1000) {
                    $portableBattery = Get-CimInstance -Namespace root\wmi -ClassName BatteryStatus -ErrorAction SilentlyContinue | Select-Object -First 1

                    if ($portableBattery) {
                        # Voltage
                        if ($portableBattery.Voltage -and $portableBattery.Voltage -gt 0) {
                            $currentVolts = [math]::Round(([double]$portableBattery.Voltage / 1000.0), 2)
                            if ($currentVolts -gt 0) {
                                $voltages += $currentVolts
                            }
                        }

                        # Charge rate (positive = charging, negative = discharging)
                        if ($portableBattery.ChargeRate) {
                            $currentWatts = [math]::Round(([double]$portableBattery.ChargeRate / 1000.0), 2)
                            $powers += $currentWatts

                            if ($currentWatts -gt 0) {
                                $chargeRates += $currentWatts
                                $adapterTest.ChargingRate.IsCharging = $true
                            }

                            # Calculate current if we have voltage and power
                            if ($voltages.Count -gt 0 -and $currentWatts -gt 0) {
                                $lastVolts = $voltages[-1]
                                if ($lastVolts -gt 0) {
                                    $currentAmps = [math]::Round(($currentWatts / $lastVolts), 2)
                                    if ($currentAmps -gt 0) {
                                        $currents += $currentAmps
                                    }
                                }
                            }
                        }
                    }

                    $lastCheck = $stopwatch.ElapsedMilliseconds
                }
            }

            $stopwatch.Stop()

            # Get final battery level
            $batteryEnd = Get-CimInstance -Namespace root\wmi -ClassName BatteryStatus -ErrorAction SilentlyContinue | Select-Object -First 1
            if ($batteryEnd -and $batteryEnd.RemainingCapacity -and $batteryEnd.MaxCapacity) {
                $adapterTest.BatteryLevel.End = [math]::Round((([double]$batteryEnd.RemainingCapacity / [double]$batteryEnd.MaxCapacity) * 100), 1)
                $adapterTest.BatteryLevel.Delta = [math]::Round(($adapterTest.BatteryLevel.End - $adapterTest.BatteryLevel.Start), 2)
            }

            # Calculate statistics
            if ($voltages.Count -gt 0) {
                $adapterTest.Voltage.Current = $voltages[-1]
                $adapterTest.Voltage.Min = [math]::Round(($voltages | Measure-Object -Minimum).Minimum, 2)
                $adapterTest.Voltage.Max = [math]::Round(($voltages | Measure-Object -Maximum).Maximum, 2)
                $adapterTest.Voltage.Avg = [math]::Round(($voltages | Measure-Object -Average).Average, 2)

                # Check voltage stability (should be within 5% of average)
                $voltageVariance = $adapterTest.Voltage.Max - $adapterTest.Voltage.Min
                $voltageVariancePercent = [math]::Round(($voltageVariance / $adapterTest.Voltage.Avg) * 100, 1)

                if ($voltageVariancePercent -lt 3) {
                    $adapterTest.Voltage.Stability = "Excellent"
                } elseif ($voltageVariancePercent -lt 5) {
                    $adapterTest.Voltage.Stability = "Good"
                } elseif ($voltageVariancePercent -lt 10) {
                    $adapterTest.Voltage.Stability = "Fair"
                    $adapterTest.Issues += "Voltage fluctuation detected ($voltageVariancePercent percent variance)"
                } else {
                    $adapterTest.Voltage.Stability = "Poor"
                    $adapterTest.Issues += "High voltage instability ($voltageVariancePercent percent variance)"
                }
            }

            if ($currents.Count -gt 0) {
                $adapterTest.Current.Current = $currents[-1]
                $adapterTest.Current.Min = [math]::Round(($currents | Measure-Object -Minimum).Minimum, 2)
                $adapterTest.Current.Max = [math]::Round(($currents | Measure-Object -Maximum).Maximum, 2)
                $adapterTest.Current.Avg = [math]::Round(($currents | Measure-Object -Average).Average, 2)
            }

            if ($powers.Count -gt 0) {
                $adapterTest.Power.Current = $powers[-1]
                $adapterTest.Power.Min = [math]::Round(($powers | Measure-Object -Minimum).Minimum, 2)
                $adapterTest.Power.Max = [math]::Round(($powers | Measure-Object -Maximum).Maximum, 2)
                $adapterTest.Power.Avg = [math]::Round(($powers | Measure-Object -Average).Average, 2)

                # Estimate adapter rating (round up to common wattages)
                $avgPower = $adapterTest.Power.Avg
                if ($avgPower -gt 0) {
                    $commonWattages = @(45, 65, 90, 120, 135, 150, 180, 230, 240, 330)
                    $estimatedRating = 65  # default
                    foreach ($wattage in $commonWattages) {
                        if ($avgPower -le ($wattage * 0.85)) {  # Adapters typically deliver 85% under load
                            $estimatedRating = $wattage
                            break
                        }
                    }
                    $adapterTest.Power.EstimatedRating = "$estimatedRating W"
                }
            }

            if ($chargeRates.Count -gt 0) {
                $adapterTest.ChargingRate.Current = $chargeRates[-1]
                $adapterTest.ChargingRate.Min = [math]::Round(($chargeRates | Measure-Object -Minimum).Minimum, 2)
                $adapterTest.ChargingRate.Max = [math]::Round(($chargeRates | Measure-Object -Maximum).Maximum, 2)
                $adapterTest.ChargingRate.Avg = [math]::Round(($chargeRates | Measure-Object -Average).Average, 2)
            }

            # Determine overall health
            $healthScore = 100

            # Check charging functionality (but allow for 100% battery)
            $currentBatteryLevel = $adapterTest.BatteryLevel.Start
            if (-not $adapterTest.ChargingRate.IsCharging) {
                # Only flag as issue if battery is not at 100%
                if ($currentBatteryLevel -lt 99) {
                    $healthScore -= 50
                    $adapterTest.Issues += "Adapter connected but battery not charging (Battery at $currentBatteryLevel percent)"
                    $adapterTest.Recommendations += "Check adapter cable and port for damage"
                    $adapterTest.Recommendations += "Try a different power outlet"
                } else {
                    $adapterTest.Recommendations += "Battery is fully charged ($currentBatteryLevel percent) - not charging is normal"
                }
            }

            # Check voltage stability
            if ($adapterTest.Voltage.Stability -eq "Poor") {
                $healthScore -= 30
                $adapterTest.Recommendations += "Adapter may be failing - consider replacement"
            } elseif ($adapterTest.Voltage.Stability -eq "Fair") {
                $healthScore -= 15
                $adapterTest.Recommendations += "Monitor adapter performance - slight instability detected"
            }

            # Check charging rate
            if ($adapterTest.ChargingRate.Avg -gt 0 -and $adapterTest.ChargingRate.Avg -lt 15) {
                $healthScore -= 20
                $adapterTest.Issues += "Low charging rate detected ($(adapterTest.ChargingRate.Avg)W)"
                $adapterTest.Recommendations += "Adapter may be underpowered or degraded"
            }

            # Assign health rating
            if ($healthScore -ge 85) {
                $adapterTest.Health = "Excellent"
            } elseif ($healthScore -ge 70) {
                $adapterTest.Health = "Good"
            } elseif ($healthScore -ge 50) {
                $adapterTest.Health = "Fair"
            } else {
                $adapterTest.Health = "Poor"
            }

            # Add generic recommendations if everything is good
            if ($adapterTest.Issues.Count -eq 0) {
                $adapterTest.Recommendations += "Adapter is functioning properly"
                $adapterTest.Recommendations += "Keep adapter cable organized to prevent damage"
                $adapterTest.Recommendations += "Avoid exposing adapter to extreme temperatures"
            }

            # Add notes about measurements
            $adapterTest.Notes = @()
            $adapterTest.Notes += "Battery Voltage: $($adapterTest.Voltage.Avg)V (voltage measured at battery terminals)"
            $adapterTest.Notes += "Typical laptop adapter output: 19-20V DC (cannot be directly measured from system)"
            if ($adapterTest.Power.EstimatedRating -ne "Unknown") {
                $adapterTest.Notes += "Estimated Adapter Power Rating: $($adapterTest.Power.EstimatedRating)"
            }
            if ($adapterTest.Current.Avg -gt 0) {
                $adapterTest.Notes += "Charging Current: $($adapterTest.Current.Avg)A (calculated from power and voltage)"
            }

            $adapterTest.Tested = $true

        } else {
            $adapterTest.Health = "Unable to Test"
        }

    } catch {
        $adapterTest.Health = "Test Failed"
        $adapterTest.Issues += "Error during testing: $($_.Exception.Message)"
    }

    return $adapterTest
}

function Get-DesktopPowerInfo {
    # Note: Windows generally cannot read internal PSU wattage/health via WMI on consumer/workstation desktops.
    $info = @{
        Type = "Desktop"
        ActivePowerPlan = "Unknown"
        ActivePowerPlanGuid = "N/A"
        ActivePowerPlanSource = "N/A"
        UPSDetected = $false
        UPSName = "N/A"
		PsuWattage = "N/A"
		PsuWattageSource = "N/A"
		PowerDrawWatts = "N/A"
		PowerDrawSource = "N/A"
		CpuPackagePowerWatts = "N/A"
		GpuPowerWatts = "N/A"
		SensorProvider = "None"
		FanReadings = @()
        Notes = @(
            "Desktop PSUs typically do not expose health/wattage to Windows via standard APIs."
        )
        Recommendations = @(
            "If you suspect power issues: check PSU wattage/brand label, inspect cables, and monitor stability under load."
        )
        Tested = $true
    }

	# Ensure WMI is available (best-effort)
	try { $null = Ensure-WmiServiceRunning } catch { }

    # Active power plan
    try {
        $plan = Get-CimInstance -Namespace root\cimv2\power -ClassName Win32_PowerPlan -Filter "IsActive=true" -ErrorAction Stop
        if ($plan) {
            $info.ActivePowerPlan = $plan.ElementName
            $info.ActivePowerPlanGuid = ($plan.InstanceID -replace '.*\\{','{' -replace '\\}.*','}')
            $info.ActivePowerPlanSource = "Win32_PowerPlan"
        }
    } catch {
        try {
            $out = (powercfg /getactivescheme 2>$null) | Out-String
            if ($out -match "GUID:\s*([0-9a-fA-F-]{36})\s*\(([^\)]+)\)") {
                $info.ActivePowerPlanGuid = $matches[1]
                $info.ActivePowerPlan = $matches[2]
                $info.ActivePowerPlanSource = "powercfg"
            }
        } catch { }
    }

    # UPS (best-effort): some UPS devices can appear as Win32_Battery.
    try {
        $batt = Get-CimInstance -ClassName Win32_Battery -ErrorAction SilentlyContinue
        if ($batt) {
            $info.UPSDetected = $true
            $info.UPSName = ($batt | Select-Object -First 1).Name
            $info.Notes += "A battery-like power device was detected (could be a UPS)."
        }
    } catch { }

	# PSU wattage (RATED) via WMI (rarely populated on desktops, but try anyway)
	try {
		$psus = @(Get-CimInstance -ClassName Win32_PowerSupply -ErrorAction Stop)
		if ($psus.Count -gt 0) {
			$psu = $psus | Select-Object -First 1
			$propsToTry = @("TotalOutputPower","MaxOutputWattage","PowerCapacity")
			foreach ($p in $propsToTry) {
				try {
					if ($psu.PSObject.Properties.Name -contains $p) {
						$val = [double]$psu.$p
						if ($val -gt 0 -and $val -lt 5000) {
							$info.PsuWattage = "$([math]::Round($val,0)) W"
							$info.PsuWattageSource = "Win32_PowerSupply.$p"
							$info.Notes += "PSU wattage was obtained from WMI (uncommon; verify against PSU label)."
							break
						}
					}
				} catch { }
			}
		}
	} catch { }

		# PSU wattage (RATED) via CIM (sometimes exists even when Win32_PowerSupply is empty)
		if ($info.PsuWattage -eq 'N/A') {
			try {
				$psus2 = @(Get-CimInstance -Namespace root\cimv2 -ClassName CIM_PowerSupply -ErrorAction Stop)
				if ($psus2.Count -gt 0) {
					$psu2 = $psus2 | Select-Object -First 1
					$propsToTry2 = @('RatedOutputPower','NameplatePower','TotalOutputPower','MaxOutputWattage','PowerCapacity')
					foreach ($p2 in $propsToTry2) {
						try {
							if ($psu2.PSObject.Properties.Name -contains $p2) {
								$val2 = [double]$psu2.$p2
								if ($val2 -gt 0 -and $val2 -lt 5000) {
									$info.PsuWattage = "$([math]::Round($val2,0)) W"
									$info.PsuWattageSource = "CIM_PowerSupply.$p2"
									$info.Notes += "PSU wattage was obtained from CIM (uncommon; verify against PSU label)."
									break
								}
							}
						} catch { }
					}
				}
			} catch { }
		}

	# Sensor provider (best-effort): LibreHardwareMonitor / OpenHardwareMonitor WMI namespaces
	try {
		$providers = @(
			@{ Namespace = 'root\LibreHardwareMonitor'; Name = 'LibreHardwareMonitor WMI' },
			@{ Namespace = 'root\OpenHardwareMonitor'; Name = 'OpenHardwareMonitor WMI' }
		)

		foreach ($prov in $providers) {
			$sensors = $null
			try {
				$sensors = @(Get-CimInstance -Namespace $prov.Namespace -ClassName Sensor -ErrorAction Stop)
			} catch { $sensors = $null }

			if (-not $sensors -or $sensors.Count -eq 0) { continue }

			$info.SensorProvider = $prov.Name

			# Fan readings
			try {
				$fans = @($sensors | Where-Object { $_.SensorType -eq 'Fan' -and $_.Value -ne $null } | Sort-Object -Property Value -Descending)
				if ($fans.Count -gt 0) {
					$info.FanReadings = @($fans | Select-Object -First 6 | ForEach-Object { "$($_.Name): $([math]::Round([double]$_.Value,0)) RPM" })
				}
			} catch { }

			# Power readings
			try {
				$power = @($sensors | Where-Object { $_.SensorType -eq 'Power' -and $_.Value -ne $null })
				if ($power.Count -gt 0) {
					$systemLike = $power | Where-Object { $_.Name -match '(?i)Total\s*System|System\s*Power|Total\s*Power|PSU|Input\s*Power' -or $_.Identifier -match '(?i)/psu/' }
					$bestSystem = @($systemLike | Sort-Object -Property Value -Descending)[0]
					if ($bestSystem -and $bestSystem.Value -ne $null) {
						$w = [math]::Round([double]$bestSystem.Value, 0)
						$info.PowerDrawWatts = "$w W"
						$info.PowerDrawSource = "$($prov.Name) ($($bestSystem.Name))"
					}

					$cpuLike = $power | Where-Object { ($_.Name -match '(?i)CPU' -or $_.Identifier -match '(?i)/cpu/') -and $_.Name -match '(?i)Package|CPU' }
					$bestCpu = @($cpuLike | Sort-Object -Property Value -Descending)[0]
					if ($bestCpu -and $bestCpu.Value -ne $null) {
						$info.CpuPackagePowerWatts = "$([math]::Round([double]$bestCpu.Value,0)) W"
					}

					$gpuLike = $power | Where-Object { ($_.Name -match '(?i)GPU' -or $_.Identifier -match '(?i)/gpu/') }
					$bestGpu = @($gpuLike | Sort-Object -Property Value -Descending)[0]
					if ($bestGpu -and $bestGpu.Value -ne $null) {
						$info.GpuPowerWatts = "$([math]::Round([double]$bestGpu.Value,0)) W"
					}

					if ($info.PowerDrawWatts -eq 'N/A' -and ($bestCpu -or $bestGpu)) {
						$sum = 0.0
						if ($bestCpu -and $bestCpu.Value -ne $null) { $sum += [double]$bestCpu.Value }
						if ($bestGpu -and $bestGpu.Value -ne $null) { $sum += [double]$bestGpu.Value }
						if ($sum -gt 0) {
							$info.PowerDrawWatts = "$([math]::Round($sum,0)) W"
							$info.PowerDrawSource = "$($prov.Name) (CPU+GPU sum)"
							$info.Notes += "Power draw is estimated from available sensors; this is not the PSU's rated wattage."
						}
					}
				}
			} catch { }

			# If a provider is available, stop at the first successful provider
			break
		}
	} catch { }

	if ($info.SensorProvider -eq 'None') {
		$info.Notes += "For real-time fan/power sensors, run LibreHardwareMonitor or OpenHardwareMonitor with WMI enabled." 
		$info.Recommendations += "Optional: Install/run LibreHardwareMonitor (enable WMI) to expose fan speeds and power draw to this report."
	}

    return $info
}

function Get-TemperatureInfo {
	    $tempInfo = @{
        CPUTemp = "N/A"
        Status = "Unknown"
        Warning = $false
        CelsiusValue = 0
	        Source = "N/A"
		        Notes = @()
        StressTest = @{
            Before = 0
            After = 0
            Delta = 0
            Tested = $false
        }
    }

	    $reading = Get-CPUTemperatureReading
	    if ($reading -and $null -ne $reading.Celsius) {
	        $celsius = [double]$reading.Celsius
	        $tempInfo.Source = [string]$reading.Source
	        $tempInfo.CelsiusValue = $celsius
	        $tempInfo.CPUTemp = "$celsius C"

	        if ($celsius -lt 0) {
	            $tempInfo.Status = "Sensor Error"
	        } elseif ($celsius -lt 50) {
	            $tempInfo.Status = "Excellent - Cool"
	        } elseif ($celsius -lt 65) {
	            $tempInfo.Status = "Good - Normal"
	        } elseif ($celsius -lt 75) {
	            $tempInfo.Status = "Warm - Acceptable"
	        } elseif ($celsius -lt 85) {
	            $tempInfo.Status = "Hot - Consider Cleaning"
	            $tempInfo.Warning = $true
	        } else {
	            $tempInfo.Status = "Critical - Cooling Issue!"
	            $tempInfo.Warning = $true
	        }

	        # Run stress test only when a sensor is readable
	        $stressResult = Test-CPUTemperature
	        $tempInfo.StressTest = $stressResult
	    } else {
	        $tempInfo.CPUTemp = "N/A"
	        $tempInfo.Status = "Sensor Not Found"
		        $tempInfo.Source = "No readable temperature sensors (ACPI/PerfCounter/LHM/OHM)"
		        $tempInfo.Notes += "Many desktops/workstations do not expose CPU temperature to Windows via standard APIs."
		        $tempInfo.Notes += "If you install/run LibreHardwareMonitor or OpenHardwareMonitor with WMI enabled, this tool can read temperatures from their WMI namespaces."
	    }

    return $tempInfo
}

function Get-SanitizedSerial {
    param([string]$Serial)
    if ([string]::IsNullOrWhiteSpace($Serial) -or
        $Serial -match '(?i)^(To Be Filled|O\.?E\.?M\.?|Default string|Not Specified|None|System Serial|0+|N/?A|Unknown|Chassis Serial|Empty|^\.+$)') {
        return "Not Available"
    }
    $cleaned = $Serial.Trim()
    # Try to decode hex-encoded serial numbers (common on NVMe/SATA drives via WMI)
    $decoded = Convert-HexSerial $cleaned
    if ($decoded) { return $decoded }
    # If hex-looking with underscores/separators AND contains hex letters, reformat to clean groups of 4
    if ($cleaned -match '[_\-]' -and $cleaned -match '^[0-9A-Fa-f_\-\s]+$' -and ($cleaned -replace '[_\-\s]','').Length -ge 8) {
        $hexClean = ($cleaned -replace '[_\-\s]','').ToUpper()
        if ($hexClean -match '^[0-9A-F]+$' -and $hexClean -match '[A-F]') {
            # Strip trailing zeros
            $hexClean = $hexClean -replace '0+$', ''
            if ($hexClean.Length -ge 4) {
                return ($hexClean -replace '(.{4})', '$1 ').Trim()
            }
        }
    }
    return $cleaned
}

function Convert-HexSerial {
    param([string]$Raw)
    # Detect hex-encoded serials: patterns like "3455_4630_4EC0..." or "5330325A4E454A43..."
    # WMI often returns NVMe/SATA serials as hex-encoded ASCII strings
    $hex = $Raw -replace '[_\s\-]', ''
    # Must be all hex chars, even length, and at least 8 chars
    if ($hex.Length -lt 8 -or $hex.Length % 2 -ne 0 -or $hex -notmatch '^[0-9A-Fa-f]+$') { return $null }
    # Pure numeric strings could be valid decimal serials — skip those
    if ($hex -notmatch '[A-Fa-f]') { return $null }
    try {
        $bytes = New-Object byte[] ($hex.Length / 2)
        for ($i = 0; $i -lt $hex.Length; $i += 2) {
            $bytes[$i / 2] = [Convert]::ToByte($hex.Substring($i, 2), 16)
        }
        # Try direct decode
        $directAscii = -join ($bytes | ForEach-Object { if ($_ -ge 0x20 -and $_ -le 0x7E) { [char]$_ } else { '.' } })
        $directPrintable = ($directAscii.ToCharArray() | Where-Object { $_ -ne '.' }).Count
        # Try byte-swapped decode (NVMe convention: each 2-byte word has bytes swapped)
        $swapped = New-Object byte[] $bytes.Length
        for ($i = 0; $i -lt $bytes.Length - 1; $i += 2) {
            $swapped[$i] = $bytes[$i + 1]; $swapped[$i + 1] = $bytes[$i]
        }
        if ($bytes.Length % 2 -eq 1) { $swapped[$bytes.Length - 1] = $bytes[$bytes.Length - 1] }
        $swapAscii = -join ($swapped | ForEach-Object { if ($_ -ge 0x20 -and $_ -le 0x7E) { [char]$_ } else { '.' } })
        $swapPrintable = ($swapAscii.ToCharArray() | Where-Object { $_ -ne '.' }).Count
        $totalChars = $bytes.Length
        # Pick the better decoding; require at least 75% printable ASCII
        $bestAscii = if ($directPrintable -ge $swapPrintable) { $directAscii } else { $swapAscii }
        $bestCount = [math]::Max($directPrintable, $swapPrintable)
        if ($bestCount -ge [math]::Ceiling($totalChars * 0.75)) {
            $result = ($bestAscii -replace '[\.\x00]+$', '').Trim()
            if ($result.Length -ge 4 -and $result -notmatch '\.\.') { return $result }
        }
    } catch { }
    return $null
}

function Get-MotherboardSlotInfo {
    param(
        [int]$RamModulesUsed = 0,
        [int]$NvmeDrivesUsed = 0,
        [int]$SataDrivesUsed = 0
    )

    $info = @{
        RAMSlotsTotal = 0
        RAMSlotsUsed = $RamModulesUsed
        PCIeSlotsTotal = 0
        M2SlotsTotal = 0
        M2SlotsUsed = $NvmeDrivesUsed
        SATAPortsEstimated = 0
        SATADrivesUsed = $SataDrivesUsed
        Notes = @()
    }

    try {
        $memArray = Get-CimInstance Win32_PhysicalMemoryArray -ErrorAction SilentlyContinue | Select-Object -First 1
        if ($memArray -and $memArray.MemoryDevices) {
            $info.RAMSlotsTotal = [int]$memArray.MemoryDevices
        }
    } catch { }
    if (-not $info.RAMSlotsTotal -or $info.RAMSlotsTotal -le 0) {
        $info.RAMSlotsTotal = [math]::Max($info.RAMSlotsUsed, 2)
        $info.Notes += "RAM slot count is estimated (Win32_PhysicalMemoryArray not available)."
    }

    $systemSlots = @()
    try { $systemSlots = @(Get-CimInstance Win32_SystemSlot -ErrorAction SilentlyContinue) } catch { $systemSlots = @() }
    if ($systemSlots.Count -gt 0) {
        $pci = @($systemSlots | Where-Object { ($_.SlotDesignation -match '(?i)PCI') -or ($_.Description -match '(?i)PCI') })
        $info.PCIeSlotsTotal = $pci.Count

        $m2 = @($systemSlots | Where-Object { ($_.SlotDesignation -match '(?i)M\.?2|NGFF') -or ($_.Description -match '(?i)M\.?2|NGFF') })
        $info.M2SlotsTotal = $m2.Count
    }

    if (-not $info.M2SlotsTotal -or $info.M2SlotsTotal -le 0) {
        if ($info.M2SlotsUsed -gt 0) {
            $info.M2SlotsTotal = $info.M2SlotsUsed
            $info.Notes += "M.2/NVMe slot count is estimated from detected NVMe drives."
        } else {
            $info.M2SlotsTotal = 0
            $info.Notes += "M.2/NVMe slot count could not be detected reliably on Windows."
        }
    }

    try {
        $ideControllers = @(Get-CimInstance Win32_IDEController -ErrorAction SilentlyContinue)
        if ($ideControllers.Count -gt 0) {
            $info.SATAPortsEstimated = [int]($ideControllers.Count * 2)
            $info.Notes += "SATA ports are estimated from IDE/AHCI controllers (rough heuristic)."
        }
    } catch { }

    return $info
}
#endregion

#region Main Diagnostic Tests

    # Ensure WMI is available before any CIM/WMI queries (best-effort)
    $testData.WmiService = Ensure-WmiServiceRunning
	    if ($testData.WmiService -and $testData.WmiService.ElevationRequested) {
	        Write-Host "" 
	        Write-Host $testData.WmiService.Message -ForegroundColor Yellow
	        Write-Host "" 
	        exit
	    }

Show-Progress -Status "System Information..." -Step 1
$computerInfo = Get-ComputerInfo
$os = Get-CimInstance Win32_OperatingSystem
$cpu = Get-CimInstance Win32_Processor
$bios = Get-CimInstance Win32_BIOS

# Get Motherboard info
$motherboard = $null
try { $motherboard = Get-CimInstance Win32_BaseBoard } catch { $motherboard = $null }

# Get Serial Number (BIOS/System)
$serialNumber = "Not Available"
try {
    $serialNumber = Get-SanitizedSerial $bios.SerialNumber
} catch {
    $serialNumber = "Not Available"
}

# Get Motherboard Serial Number
$motherboardSerial = "Not Available"
try {
    if ($motherboard) { $motherboardSerial = Get-SanitizedSerial $motherboard.SerialNumber }
} catch {
    $motherboardSerial = "Not Available"
}

# Get CPU Processor ID
$cpuProcessorId = "Not Available"
try {
    $cpuProcessorId = Get-SanitizedSerial $cpu.ProcessorId
} catch {
    $cpuProcessorId = "Not Available"
}

# Get Windows Activation Status
$activationStatus = "Unknown"
$licenseType = "Unknown"
try {
    $license = Get-CimInstance -ClassName SoftwareLicensingProduct -ErrorAction SilentlyContinue |
               Where-Object { $_.PartialProductKey -and $_.Name -like "*Windows*" } |
               Select-Object -First 1
    if ($license) {
        $activationStatus = switch ($license.LicenseStatus) {
            0 { "Unlicensed" }
            1 { "Activated" }
            2 { "Out of Grace" }
            3 { "Out of Tolerance" }
            4 { "Non-Genuine" }
            5 { "Notification" }
            6 { "Extended Grace" }
            default { "Unknown" }
        }

        # Determine license type from Description
        if ($license.Description -match "RETAIL") { $licenseType = "Retail" }
        elseif ($license.Description -match "OEM") { $licenseType = "OEM" }
        elseif ($license.Description -match "VOLUME|MAK|KMS") { $licenseType = "Volume" }
        elseif ($license.Description -match "TIMEBASED") { $licenseType = "Subscription" }
        else { $licenseType = "Unknown" }
    }
} catch {
    $activationStatus = "Unknown"
    $licenseType = "Unknown"
}

$testData.System = @{
    Name = $computerInfo.CsName
    Manufacturer = $computerInfo.CsManufacturer
    Model = $computerInfo.CsModel
    OS = "$($os.Caption)"
    Version = $os.Version
    BIOSVersion = $bios.SMBIOSBIOSVersion
    SerialNumber = $serialNumber
    ActivationStatus = $activationStatus
    LicenseType = $licenseType
    MotherboardSerial = $motherboardSerial
    MotherboardManufacturer = if ($motherboard) { $motherboard.Manufacturer } else { "N/A" }
    MotherboardProduct = if ($motherboard) { $motherboard.Product } else { "N/A" }
}

Show-Progress -Status "CPU Performance & Benchmark..."

$loads = @()
for ($i = 0; $i -lt 5; $i++) {
    $loads += (Get-Counter '\Processor(_Total)\% Processor Time').CounterSamples.CookedValue
    Start-Sleep -Milliseconds 500
}
$avgLoad = [math]::Round(($loads | Measure-Object -Average).Average, 1)

$cpuBenchmark = Test-CPUBenchmark

$testData.CPU = @{
    Name = $cpu.Name
    Cores = $cpu.NumberOfCores
    Threads = $cpu.NumberOfLogicalProcessors
    Speed = $cpu.MaxClockSpeed
    CurrentLoad = $avgLoad
    L2Cache = if ($cpu.L2CacheSize) { "$([math]::Round($cpu.L2CacheSize / 1024, 1)) MB" } else { "N/A" }
    L3Cache = if ($cpu.L3CacheSize) { "$([math]::Round($cpu.L3CacheSize / 1024, 1)) MB" } else { "N/A" }
    Virtualization = if ($cpu.VirtualizationFirmwareEnabled) { "Enabled" } else { "Disabled" }
    Sockets = if ($cpu.SocketDesignation) { $cpu.SocketDesignation } else { "1" }
    BenchmarkOps = $cpuBenchmark.OpsPerSecond
    BenchmarkScore = $cpuBenchmark.Score
    ProcessorId = $cpuProcessorId
}

$cpuTier = Get-HardwareTier -ComponentType "CPU" -ComponentName $cpu.Name -Database $hardwareDB
$testData.CPU.Tier = $cpuTier.Tier
$testData.CPU.TierScore = $cpuTier.Score
$testData.CPU.Category = $cpuTier.Category
$testData.CPU.EstimatedAge = (Get-Date).Year - $cpuTier.EstimatedYear

$cpuScore = if ($avgLoad -lt 70) { 7 } else { 4 }
$globalScore += $cpuScore
$globalScoreMax += 7

Show-Progress -Status "Memory (RAM)..."
$ramModules = Get-CimInstance Win32_PhysicalMemory
$totalRAM = [math]::Round(($ramModules | Measure-Object -Property Capacity -Sum).Sum / 1GB, 2)
$ramSpeed = if ($ramModules[0].Speed) { $ramModules[0].Speed } else { "Unknown" }

$ramType = "Unknown"
if ($ramModules[0].SMBIOSMemoryType) {
    $ramType = switch ($ramModules[0].SMBIOSMemoryType) {
        20 { "DDR" }; 21 { "DDR2" }; 24 { "DDR3" }
        26 { "DDR4" }; 34 { "DDR5" }
        default { "Unknown" }
    }
}
# Fallback: MemoryType property (Win10 20H1+)
if ($ramType -eq "Unknown") {
    try {
        $mt = $ramModules[0].MemoryType
        if ($mt) {
            $ramType = switch ([int]$mt) {
                20 { "DDR" }; 21 { "DDR2" }; 22 { "DDR2 FB-DIMM" }
                24 { "DDR3" }; 26 { "DDR4" }; 34 { "DDR5" }; 35 { "DDR5" }
                default { "Unknown" }
            }
        }
    } catch { }
}
# Fallback: speed-based heuristic
if ($ramType -eq "Unknown" -and $ramSpeed -and $ramSpeed -ne "Unknown") {
    $spdVal = 0; try { $spdVal = [int]($ramSpeed -replace '[^0-9]', '') } catch { $spdVal = 0 }
    if ($spdVal -ge 4800) { $ramType = "DDR5" }
    elseif ($spdVal -ge 2133) { $ramType = "DDR4" }
    elseif ($spdVal -ge 800)  { $ramType = "DDR3" }
    elseif ($spdVal -ge 400)  { $ramType = "DDR2" }
}

# Build RAM module details with serial numbers
$ramModuleDetails = @()
foreach ($mod in $ramModules) {
    $modCapacity = if ($mod.Capacity) { "$([math]::Round($mod.Capacity / 1GB, 1)) GB" } else { "Unknown" }
    $modManufacturer = if ($mod.Manufacturer -and $mod.Manufacturer.Trim() -ne "") { $mod.Manufacturer.Trim() } else { "Unknown" }
    $modPartNumber = if ($mod.PartNumber -and $mod.PartNumber.Trim() -ne "") { $mod.PartNumber.Trim() } else { "N/A" }
    $modSlot = if ($mod.DeviceLocator) { $mod.DeviceLocator } else { "Slot" }
    $modSerial = Get-SanitizedSerial $mod.SerialNumber
    $ramModuleDetails += @{
        Slot = $modSlot
        Capacity = $modCapacity
        Manufacturer = $modManufacturer
        PartNumber = $modPartNumber
        SerialNumber = $modSerial
        Speed = if ($mod.Speed) { "$($mod.Speed) MHz" } else { "Unknown" }
    }
}

$testData.Memory = @{
    Total = "$totalRAM GB"
    Modules = $ramModules.Count
    Speed = "$ramSpeed MHz"
    Type = $ramType
    ModuleDetails = $ramModuleDetails
}

$ramString = "$([math]::Round($totalRAM, 0))GB $ramType"
	# Try benchmark-backed exact RAM match using module part numbers / descriptions, then fall back to capacity-based tiers.
	$ramTier = $null
	$ramCandidates = @()
	try {
	    foreach ($m in $ramModules) {
	        $pn = $null; $man = $null; $desc = $null
	        try { $pn = ("" + $m.PartNumber).Trim() } catch { $pn = $null }
	        try { $man = ("" + $m.Manufacturer).Trim() } catch { $man = $null }
	        try { $desc = ("" + $m.Description).Trim() } catch { $desc = $null }

	        if ($man -and $pn) { $ramCandidates += ("$man $pn") }
	        if ($pn) { $ramCandidates += $pn }
	        if ($desc) { $ramCandidates += $desc }
	    }
	} catch { }

	$ramCandidates = @($ramCandidates | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | Select-Object -Unique)
	foreach ($cand in $ramCandidates) {
	    $t = Get-HardwareTier -ComponentType "RAM" -ComponentName $cand -Database $hardwareDB
	    if ($t -and ($t.Sources -or $t.Benchmarks -or $t.Specs) -and $t.Tier -ne "Unknown") {
	        if (-not $ramTier -or ([int]$t.Score -gt [int]$ramTier.Score)) { $ramTier = $t }
	    }
	}
		if (-not $ramTier -or $ramTier.Tier -eq "Unknown") {
		    $ramTier = Get-HardwareTier -ComponentType "RAM" -ComponentName @{ DDRType = $ramType; SpeedMHz = $ramSpeed } -Database $hardwareDB
		}
		if (-not $ramTier -or $ramTier.Tier -eq "Unknown") {
		    $ramTier = Get-HardwareTier -ComponentType "RAM" -ComponentName $ramString -Database $hardwareDB
		}
		# Hardcoded heuristic fallback when all DB lookups fail
		if (-not $ramTier -or $ramTier.Tier -eq "Unknown") {
		    $heurTier = "Budget"; $heurScore = 30; $heurCat = "RAM"
		    $spdVal = 0; try { $spdVal = [int]($ramSpeed -replace '[^0-9]', '') } catch { $spdVal = 0 }
		    $capGB = [math]::Round($totalRAM, 0)
		    if ($ramType -eq "DDR5") {
		        if ($capGB -ge 32) { $heurTier = "Flagship"; $heurScore = 95; $heurCat = "Workstation/High-End" }
		        elseif ($capGB -ge 16) { $heurTier = "High Performance"; $heurScore = 85; $heurCat = "Gaming/Content Creation" }
		        elseif ($capGB -ge 8)  { $heurTier = "Mainstream"; $heurScore = 70; $heurCat = "Standard DDR5" }
		        else                   { $heurTier = "Entry Level"; $heurScore = 55; $heurCat = "Low-Cap DDR5" }
		    } elseif ($ramType -eq "DDR4") {
		        if ($capGB -ge 32)     { $heurTier = "High Performance"; $heurScore = 80; $heurCat = "Content Creation" }
		        elseif ($capGB -ge 16) { $heurTier = "Mainstream"; $heurScore = 70; $heurCat = "Standard 2025" }
		        elseif ($capGB -ge 8)  { $heurTier = "Entry Level"; $heurScore = 50; $heurCat = "Minimum Recommended" }
		        else                   { $heurTier = "Budget"; $heurScore = 30; $heurCat = "Insufficient" }
		    } elseif ($ramType -eq "DDR3") {
		        if ($capGB -ge 16) { $heurTier = "Entry Level"; $heurScore = 45; $heurCat = "Legacy Adequate" }
		        elseif ($capGB -ge 8) { $heurTier = "Entry Level"; $heurScore = 40; $heurCat = "Below Standard" }
		        else { $heurTier = "Budget"; $heurScore = 25; $heurCat = "Very Limited" }
		    } else {
		        if ($capGB -ge 16) { $heurTier = "Entry Level"; $heurScore = 50; $heurCat = "RAM" }
		        elseif ($capGB -ge 8) { $heurTier = "Entry Level"; $heurScore = 45; $heurCat = "RAM" }
		        else { $heurTier = "Budget"; $heurScore = 30; $heurCat = "RAM" }
		    }
		    # Bonus for high speeds
		    if ($spdVal -ge 6000 -and $heurScore -lt 95) { $heurScore = [math]::Min($heurScore + 10, 95) }
		    elseif ($spdVal -ge 4800 -and $heurScore -lt 90) { $heurScore = [math]::Min($heurScore + 5, 90) }
		    elseif ($spdVal -ge 3600 -and $heurScore -lt 85) { $heurScore = [math]::Min($heurScore + 3, 85) }
		    $ramTier = @{ Tier = $heurTier; Score = $heurScore; Category = $heurCat; EstimatedYear = 2020 }
		}
$testData.Memory.Tier = $ramTier.Tier
$testData.Memory.TierScore = $ramTier.Score
$testData.Memory.Category = $ramTier.Category
	try { if ($ramTier.Benchmarks) { $testData.Memory.Benchmarks = $ramTier.Benchmarks } } catch { }
	try { if ($ramTier.Sources) { $testData.Memory.Sources = $ramTier.Sources } } catch { }
	try { if ($ramTier.Specs) { $testData.Memory.Specs = $ramTier.Specs } } catch { }

$ramScore = if ($totalRAM -ge 8) { 7 } elseif ($totalRAM -ge 4) { 4 } else { 2 }
$globalScore += $ramScore
$globalScoreMax += 7

Show-Progress -Status "Storage Performance..."

# ============================================================
# ENHANCED STORAGE DETECTION - Detects ALL physical disks
# ============================================================
$allDisks = @()

# Method 1: Get-PhysicalDisk (best for NVMe and modern drives)
$physicalDisks = Get-PhysicalDisk -ErrorAction SilentlyContinue
foreach ($disk in $physicalDisks) {
    # Determine media type more accurately
    $mediaType = "Unknown"
    $busType = $disk.BusType

	    # NVMe is always an SSD; ensure we don't lose this by trusting only MediaType.
	    if ($busType -eq "NVMe") {
	        $mediaType = "NVMe SSD"
	    }

    # Check MediaType property first
	    if ($mediaType -eq "Unknown" -and ($disk.MediaType -eq "SSD" -or $disk.MediaType -eq "Solid State Drive")) {
	        if ($busType -eq "SATA" -or $busType -eq "SAS") { $mediaType = "SATA SSD" }
	        else { $mediaType = "SSD" }
    } elseif ($disk.MediaType -eq "HDD" -or $disk.MediaType -eq "Hard Disk Drive") {
        $mediaType = "HDD"
    } elseif ($disk.MediaType -eq "Unspecified" -or $disk.MediaType -eq "Unknown") {
        # Use BusType to determine - NVMe is always SSD
        if ($busType -eq "NVMe") {
            $mediaType = "NVMe SSD"
        } elseif ($busType -eq "SATA" -or $busType -eq "SAS") {
            # Check spindle speed or model name for SATA drives
            if ($disk.SpindleSpeed -eq 0 -or $disk.FriendlyName -match "SSD|Solid State|NVMe|M\.2") {
                $mediaType = "SATA SSD"
            } else {
                $mediaType = "HDD"
            }
        } elseif ($busType -eq "USB") {
            $mediaType = "USB Drive"
        } else {
            # Default based on model name patterns
            if ($disk.FriendlyName -match "SSD|Solid State|NVMe|M\.2|Samsung 9[678]0|WD Black SN|Crucial|Kingston") {
                $mediaType = "SSD"
            } else {
                $mediaType = "HDD"
            }
        }
    }

    $allDisks += @{
        Model = $disk.FriendlyName
        Size = [math]::Round($disk.Size / 1GB, 2)
        SizeFormatted = "$([math]::Round($disk.Size / 1GB, 2)) GB"
        MediaType = $mediaType
        BusType = $busType
        Health = $disk.HealthStatus
	        DiskNumber = $null
        DeviceId = $disk.DeviceId
        SerialNumber = $disk.SerialNumber
        IsBootDrive = $false
    }
}

	# Method 1b: Win32_DiskDrive cross-check (helps when NVMe BusType is hidden behind RAID/storage drivers)
	try {
	    $diskDrives = @(Get-CimInstance -ClassName Win32_DiskDrive -ErrorAction SilentlyContinue)
	    if ($diskDrives -and $diskDrives.Count -gt 0 -and $allDisks -and $allDisks.Count -gt 0) {
	        $normSerial2 = {
	            param($s)
	            if ($null -eq $s) { return "" }
	            return (($s -as [string]) -replace '[^A-Za-z0-9]', '').ToUpperInvariant()
	        }

	        foreach ($d in $allDisks) {
	            try {
	                if (-not $d) { continue }
	                if ([string]$d.MediaType -match '(?i)NVMe') { continue }

	                $match = $null
	                $dSer = &$normSerial2 $d.SerialNumber
	                if ($dSer) {
	                    $match = $diskDrives | Where-Object { (&$normSerial2 $_.SerialNumber) -eq $dSer } | Select-Object -First 1
	                }
	                if (-not $match -and $d.Model) {
	                    $match = $diskDrives | Where-Object { $_.Model -and $_.Model -eq $d.Model } | Select-Object -First 1
	                }

	                if ($match) {
	                    $isNvme = $false
	                    try {
	                        if ($match.PNPDeviceID -match '(?i)NVME') { $isNvme = $true }
	                        elseif ($match.Model -match '(?i)NVMe') { $isNvme = $true }
	                    } catch { }

	                    if ($isNvme) {
	                        $d.MediaType = 'NVMe SSD'
	                        $d.BusType = 'NVMe'
	                    }
	                }
	            } catch { }
	        }
	    }
	} catch { }

	# Method 1c: Cross-reference Get-PhysicalDisk rows to Get-Disk (to get reliable DiskNumber)
	try {
		$osDisks = @(Get-Disk -ErrorAction SilentlyContinue)
		if ($osDisks -and $osDisks.Count -gt 0 -and $allDisks -and $allDisks.Count -gt 0) {
			$normSerial3 = {
				param($s)
				if ($null -eq $s) { return "" }
				return (($s -as [string]) -replace '[^A-Za-z0-9]', '').ToUpperInvariant()
			}
			foreach ($d in $allDisks) {
				try {
					if (-not $d) { continue }
					if ($d.ContainsKey('DiskNumber') -and $null -ne $d.DiskNumber) { continue }

					$matchDisk = $null
					$dSer = &$normSerial3 $d.SerialNumber
					if ($dSer) {
						$matchDisk = $osDisks | Where-Object { $_.SerialNumber -and (&$normSerial3 $_.SerialNumber) -eq $dSer } | Select-Object -First 1
					}
					if (-not $matchDisk -and $d.Model) {
						$matchDisk = $osDisks | Where-Object { $_.FriendlyName -and $_.FriendlyName -eq $d.Model } | Select-Object -First 1
					}
					if ($matchDisk) {
						$d.DiskNumber = [int]$matchDisk.Number
					}
				} catch { }
			}
		}
	} catch { }

	# Method 2: Cross-reference with Get-Disk to find boot drive
try {
		# Reset first to guarantee ONLY one [BOOT] label.
		foreach ($d in $allDisks) { $d.IsBootDrive = $false }

		$windowsDrive = (Get-CimInstance Win32_OperatingSystem -ErrorAction Stop).SystemDrive
		$bootPartition = Get-Partition -DriveLetter $windowsDrive.TrimEnd(':') -ErrorAction SilentlyContinue
		if ($bootPartition) {
			$bootDiskNumber = $bootPartition.DiskNumber
			$bootDisk = $null
			try { $bootDisk = Get-Disk -Number $bootDiskNumber -ErrorAction SilentlyContinue } catch { }

			# Prefer exact disk-number match (most reliable)
			$bootMatch = $allDisks | Where-Object { $_.DiskNumber -ne $null -and $_.DiskNumber -eq $bootDiskNumber } | Select-Object -First 1

			# Fallback: unique serial match
			if (-not $bootMatch -and $bootDisk -and $bootDisk.SerialNumber) {
				$normSerial = {
					param($s)
					if ($null -eq $s) { return "" }
					return (($s -as [string]) -replace '[^A-Za-z0-9]', '').ToUpperInvariant()
				}
				$bootSerialNorm = (&$normSerial $bootDisk.SerialNumber)
				$serialMatches = @($allDisks | Where-Object { $_.SerialNumber -and (&$normSerial $_.SerialNumber) -eq $bootSerialNorm })
				if ($serialMatches.Count -eq 1) { $bootMatch = $serialMatches[0] }
			}

			# Last resort: only accept a UNIQUE model match
			if (-not $bootMatch -and $bootDisk -and $bootDisk.FriendlyName) {
				$modelMatches = @($allDisks | Where-Object { $_.Model -and ($_.Model -eq $bootDisk.FriendlyName) })
				if ($modelMatches.Count -eq 1) { $bootMatch = $modelMatches[0] }
			}

			if ($bootMatch) { $bootMatch.IsBootDrive = $true }
		}
} catch {}

# Sort: Boot drive first, then by size (largest first)
$allDisks = $allDisks | Sort-Object -Property @{Expression={$_.IsBootDrive}; Descending=$true}, @{Expression={$_.Size}; Descending=$true}

	# Select primary disk (prefer boot disk; if unknown, prefer fastest type)
	$primaryDisk = $allDisks | Where-Object { $_.IsBootDrive } | Select-Object -First 1
	if (-not $primaryDisk) {
	    $primaryDisk = $allDisks | Where-Object { $_.MediaType -match "(?i)NVMe" } | Sort-Object -Property Size -Descending | Select-Object -First 1
	}
	if (-not $primaryDisk) {
	    $primaryDisk = $allDisks | Where-Object { $_.MediaType -match "(?i)SSD" } | Sort-Object -Property Size -Descending | Select-Object -First 1
	}
	if (-not $primaryDisk) { $primaryDisk = $allDisks | Select-Object -First 1 }

# Calculate total storage
$totalStorageGB = ($allDisks | Measure-Object -Property Size -Sum).Sum
$ssdCount = ($allDisks | Where-Object { $_.MediaType -match "SSD|NVMe" }).Count
$hddCount = ($allDisks | Where-Object { $_.MediaType -eq "HDD" }).Count
$nvmeCount = ($allDisks | Where-Object { $_.MediaType -match "NVMe" -or $_.BusType -eq "NVMe" }).Count

	# Motherboard expansion/slot summary (best-effort / estimated)
	$sataDrivesUsed = ($allDisks | Where-Object { $_.BusType -match "SATA|SAS" -or $_.MediaType -match "(?i)HDD|SATA SSD" }).Count
	$testData.MotherboardSlots = Get-MotherboardSlotInfo -RamModulesUsed $ramModules.Count -NvmeDrivesUsed $nvmeCount -SataDrivesUsed $sataDrivesUsed

	# Run IO test on the SystemDrive (more stable than $env:TEMP which can be redirected)
	$systemDrive = $null
	try { $systemDrive = (Get-CimInstance Win32_OperatingSystem -ErrorAction Stop).SystemDrive } catch { $systemDrive = $env:SystemDrive }
	if (-not $systemDrive) { $systemDrive = "C:" }
	$testDir = Join-Path ($systemDrive + "\") "Users\Public\LaptopDiagnosticTemp"
	try { if (-not (Test-Path $testDir)) { New-Item -ItemType Directory -Path $testDir -Force | Out-Null } } catch { $testDir = $env:TEMP }
	$testFile = Join-Path $testDir "speed_test.tmp"

	# Larger test sizes reduce caching effects (still kept reasonable for a quick diagnostic)
	$testSize = 32MB
	if ($primaryDisk.MediaType -match "(?i)NVMe") { $testSize = 64MB }
	elseif ($primaryDisk.MediaType -match "(?i)SSD") { $testSize = 48MB }

# Initialize storage data with ALL disks
$testData.Storage = @{
    Model = $primaryDisk.Model
    Size = $primaryDisk.SizeFormatted
	    # Preserve detailed media type so NVMe vs SATA SSD is not lost (affects tier scoring and UI)
	    MediaType = $primaryDisk.MediaType
    DetailedType = $primaryDisk.MediaType
    BusType = $primaryDisk.BusType
    Health = $primaryDisk.Health
    WriteSpeed = "N/A"
    ReadSpeed = "N/A"
    IsBootDrive = $primaryDisk.IsBootDrive
    SerialNumber = Get-SanitizedSerial $primaryDisk.SerialNumber
    AllDisks = $allDisks
    TotalDisks = $allDisks.Count
    TotalStorageGB = [math]::Round($totalStorageGB, 0)
    SSDCount = $ssdCount
    HDDCount = $hddCount
    NVMeCount = $nvmeCount
}

try {
    $randomData = New-Object byte[] $testSize
    (New-Object Random).NextBytes($randomData)

    $writeTimer = [System.Diagnostics.Stopwatch]::StartNew()
    [System.IO.File]::WriteAllBytes($testFile, $randomData)
    $writeTimer.Stop()

    $writeSpeed = [math]::Round(($testSize / 1MB) / ($writeTimer.ElapsedMilliseconds / 1000), 2)
    $testData.Storage.WriteSpeed = "$writeSpeed MB/s"

    $readTimer = [System.Diagnostics.Stopwatch]::StartNew()
    $null = [System.IO.File]::ReadAllBytes($testFile)
    $readTimer.Stop()

    $readSpeed = [math]::Round(($testSize / 1MB) / ($readTimer.ElapsedMilliseconds / 1000), 2)
    $testData.Storage.ReadSpeed = "$readSpeed MB/s"

    Remove-Item $testFile -Force -ErrorAction SilentlyContinue

    $avgSpeed = [math]::Round(($writeSpeed + $readSpeed) / 2, 0)
    $testData.Storage.AvgSpeed = $avgSpeed

} catch {
    $testData.Storage.WriteSpeed = "Test Failed"
    $testData.Storage.ReadSpeed = "Test Failed"
	    # Conservative defaults when the quick IO test fails.
	    # NVMe should not tier like SATA SSD/HDD just because the test failed.
	    if ($testData.Storage.MediaType -match "(?i)NVMe") { $avgSpeed = 2500 }
	    elseif ($testData.Storage.MediaType -match "(?i)SSD") { $avgSpeed = 550 }
	    else { $avgSpeed = 120 }
    $testData.Storage.AvgSpeed = $avgSpeed
}

$storageString = "$([math]::Round($primaryDisk.Size, 0))|$($testData.Storage.MediaType)|$avgSpeed"
	$storageTierInput = @{ Model = $primaryDisk.Model; LegacyString = $storageString }
	$storageTier = Get-HardwareTier -ComponentType "Storage" -ComponentName $storageTierInput -Database $hardwareDB
	# Hardcoded heuristic fallback when all DB lookups fail
	if (-not $storageTier -or $storageTier.Tier -eq "Unknown") {
	    $sType = $testData.Storage.MediaType
	    $sSpd = 0; try { $sSpd = [int]$avgSpeed } catch { $sSpd = 0 }
	    if ($sType -match "(?i)NVMe") {
	        if ($sSpd -ge 5000)      { $storageTier = @{ Tier = "Flagship"; Score = 95; Category = "Professional Grade NVMe" } }
	        elseif ($sSpd -ge 3000)  { $storageTier = @{ Tier = "High Performance"; Score = 85; Category = "High-Speed NVMe" } }
	        elseif ($sSpd -ge 1500)  { $storageTier = @{ Tier = "Mainstream"; Score = 75; Category = "Fast NVMe" } }
	        else                     { $storageTier = @{ Tier = "Mid-Range"; Score = 65; Category = "NVMe SSD" } }
	    } elseif ($sType -match "(?i)SSD") {
	        if ($sSpd -ge 500)       { $storageTier = @{ Tier = "Mid-Range"; Score = 60; Category = "Standard SSD" } }
	        elseif ($sSpd -ge 200)   { $storageTier = @{ Tier = "Entry Level"; Score = 50; Category = "Slow SSD" } }
	        else                     { $storageTier = @{ Tier = "Entry Level"; Score = 45; Category = "SATA SSD" } }
	    } else {
	        if ($sSpd -ge 100)       { $storageTier = @{ Tier = "Budget"; Score = 30; Category = "Mechanical Drive" } }
	        else                     { $storageTier = @{ Tier = "Legacy"; Score = 20; Category = "Very Slow" } }
	    }
	}
$testData.Storage.Tier = $storageTier.Tier
$testData.Storage.TierScore = $storageTier.Score
$testData.Storage.Category = $storageTier.Category
	try { if ($storageTier.Benchmarks) { $testData.Storage.Benchmarks = $storageTier.Benchmarks } } catch { }
	try { if ($storageTier.Sources) { $testData.Storage.Sources = $storageTier.Sources } } catch { }
	try { if ($storageTier.Specs) { $testData.Storage.Specs = $storageTier.Specs } } catch { }

# Score based on best storage (NVMe > SSD > HDD)
$storageScore = if ($nvmeCount -gt 0) { 10 } elseif ($ssdCount -gt 0) { 8 } else { 4 }
$globalScore += $storageScore
$globalScoreMax += 10

Show-Progress -Status "Battery Health..."
$batteryData = Get-BatteryInfo
$testData.Battery = $batteryData

$batteryScore = 0
$batteryStatus = "No Battery"
if ($batteryData.Detected) {
    if ($batteryData.Health -ge 85) { $batteryScore = 8; $batteryStatus = "Excellent" }
    elseif ($batteryData.Health -ge 70) { $batteryScore = 6; $batteryStatus = "Good" }
    elseif ($batteryData.Health -ge 50) { $batteryScore = 4; $batteryStatus = "Fair" }
    else { $batteryScore = 2; $batteryStatus = "Poor" }
    $globalScore += $batteryScore
	$globalScoreMax += 8
} else {
	    # Desktop / no battery: do not award or deduct points.
	    $batteryScore = 0
	    $batteryStatus = "No Battery"
}

# Store for reporting/debugging
$testData.Battery.Score = $batteryScore
$testData.Battery.ScoreMax = if ($batteryData.Detected) { 8 } else { 0 }

Show-Progress -Status "AC Adapter..."
$testData.Charger = Get-ChargerInfo

Show-Progress -Status "Network & WiFi..."
$adapters = Get-NetAdapter | Where-Object { $_.Status -eq "Up" }
$testData.Network = @{
    Adapters = $adapters | ForEach-Object {
        @{
            Name = $_.Name
            Description = $_.InterfaceDescription
            Speed = "$($_.LinkSpeed)"
            MAC = $_.MacAddress
        }
    }
    WiFi = @{
        Detected = $false
        Name = "Not Found"
        Speed = "N/A"
        Status = "N/A"
        SignalStrength = "N/A"
    }
}

# FIXED WiFi detection - more comprehensive
$allAdapters = Get-NetAdapter
$wifiAdapter = $allAdapters | Where-Object {
    $_.InterfaceDescription -notmatch "Ethernet|Gigabit|10/100|LAN|RJ45|GbE|Virtual|Bluetooth" -and
    ($_.InterfaceDescription -match "Wi-?Fi|Wireless|802\.11|WLAN|Centrino|Advanced-N|Dual.?Band|Killer|Qualcomm|Atheros|Realtek.*RT|Intel.*Wireless|Broadcom.*BCM43" -or
    $_.Name -match "^Wi-?Fi$|^Wireless$|^WLAN$")
} | Select-Object -First 1

if ($wifiAdapter) {
    $testData.Network.WiFi.Detected = $true
    $testData.Network.WiFi.Name = $wifiAdapter.InterfaceDescription
    $testData.Network.WiFi.Speed = if ($wifiAdapter.LinkSpeed) { $wifiAdapter.LinkSpeed } else { "N/A" }
    $testData.Network.WiFi.Status = $wifiAdapter.Status

    try {
        $wifiInfo = netsh wlan show interfaces 2>$null
        if ($wifiInfo -match "Signal\s+:\s+(\d+)%") {
            $testData.Network.WiFi.SignalStrength = "$($matches[1])%"
        }
        if ($wifiInfo -match "Receive rate.*?:\s+([\d.]+)") {
            $testData.Network.WiFi.ReceiveRate = "$($matches[1]) Mbps"
        }
        if ($wifiInfo -match "Transmit rate.*?:\s+([\d.]+)") {
            $testData.Network.WiFi.TransmitRate = "$($matches[1]) Mbps"
        }
    } catch {}
}

$globalScore += 5
$globalScoreMax += 5

$wifiMax = if ($wifiAdapter) { 4 } else { 0 }
$globalScore += if ($testData.Network.WiFi.Detected) { 4 } else { 0 }
$globalScoreMax += $wifiMax

# Bluetooth
try {
    $bluetooth = Get-PnpDevice -Class Bluetooth -Status OK -ErrorAction SilentlyContinue
    $testData.Network.Bluetooth = @{
        Detected = if ($bluetooth) { $true } else { $false }
        Devices = if ($bluetooth) { $bluetooth.Count } else { 0 }
    }
} catch {
    $testData.Network.Bluetooth = @{ Detected = $false; Devices = 0 }
}

Show-Progress -Status "Audio Devices..."
$audioDevices = Get-CimInstance Win32_SoundDevice
$testData.Audio = @{
    Devices = $audioDevices | ForEach-Object {
        @{
            Name = $_.Name
            Status = $_.Status
        }
    }
}
$globalScore += 5
$globalScoreMax += 5

Show-Progress -Status "Input Devices..."
# Filter out virtual/system devices to count only physical keyboards and mice
$allKeyboards = Get-PnpDevice -Class Keyboard -Status OK -ErrorAction SilentlyContinue
$allMice = Get-PnpDevice -Class Mouse -Status OK -ErrorAction SilentlyContinue

# Patterns to exclude virtual/system devices
$virtualPatterns = @(
    "HID Keyboard Device",
    "HID-compliant",
    "PS/2",
    "Virtual",
    "Root",
    "Composite",
    "System",
    "Remote Desktop",
    "Terminal Server",
    "Microsoft Hardware",
    "Standard PS/2",
    "PC/AT Enhanced"
)

# Count only physical keyboards (USB keyboards typically have manufacturer names)
$physicalKeyboards = @($allKeyboards | Where-Object {
    $name = $_.FriendlyName
    $isVirtual = $false
    foreach ($pattern in $virtualPatterns) {
        if ($name -match $pattern) { $isVirtual = $true; break }
    }
    -not $isVirtual
})

# Count only physical mice (USB mice typically have manufacturer names)
$physicalMice = @($allMice | Where-Object {
    $name = $_.FriendlyName
    $isVirtual = $false
    foreach ($pattern in $virtualPatterns) {
        if ($name -match $pattern) { $isVirtual = $true; break }
    }
    -not $isVirtual
})

# If no physical devices found but virtual ones exist, count at least 1 as system input
$keyboardCount = if ($physicalKeyboards.Count -gt 0) { $physicalKeyboards.Count } elseif ($allKeyboards.Count -gt 0) { 1 } else { 0 }
$mouseCount = if ($physicalMice.Count -gt 0) { $physicalMice.Count } elseif ($allMice.Count -gt 0) { 1 } else { 0 }

$testData.InputDevices = @{
    Keyboards = $keyboardCount
    PointingDevices = $mouseCount
}
$globalScore += 4
$globalScoreMax += 4

Show-Progress -Status "Temperature & Cooling..."
try {
    $testData.Temperature = Get-TemperatureInfo
} catch {
    # Never allow temperature detection to break the report; treat as sensor-not-found.
    $testData.Temperature = @{
        CPUTemp = "N/A"
        Status = "Sensor Not Found"
        Warning = $false
        CelsiusValue = 0
        Source = "Get-TemperatureInfo failed"
        Notes = @("$($_.Exception.Message)")
        StressTest = @{ Before = 0; After = 0; Delta = 0; Tested = $false }
    }
}

$tempScore = 0
$tempMax = 0
if ($testData.Temperature -and -not [string]::IsNullOrWhiteSpace([string]$testData.Temperature.CPUTemp) -and $testData.Temperature.CPUTemp -ne "N/A") {
    $tempMax = 7
    if ($testData.Temperature.CelsiusValue -lt 65) { $tempScore = 7 }
    elseif ($testData.Temperature.CelsiusValue -lt 75) { $tempScore = 5 }
    elseif ($testData.Temperature.CelsiusValue -lt 85) { $tempScore = 3 }
    else { $tempScore = 1 }
}
$globalScore += $tempScore
$globalScoreMax += $tempMax

Show-Progress -Status "Display..."
$video = Get-CimInstance Win32_VideoController | Select-Object -First 1
$monitors = Get-CimInstance WmiMonitorID -Namespace root\wmi -ErrorAction SilentlyContinue

# Calculate screen size in inches
$screenSizeInches = "N/A"
try {
    $monitorSize = Get-CimInstance WmiMonitorBasicDisplayParams -Namespace root\wmi -ErrorAction SilentlyContinue
    if ($monitorSize) {
        $widthCm = $monitorSize.MaxHorizontalImageSize
        $heightCm = $monitorSize.MaxVerticalImageSize
        if ($widthCm -gt 0 -and $heightCm -gt 0) {
            $diagonalCm = [math]::Sqrt([math]::Pow($widthCm, 2) + [math]::Pow($heightCm, 2))
            $diagonalInches = [math]::Round($diagonalCm / 2.54, 1)
            $screenSizeInches = "$diagonalInches inches"
        }
    }
} catch {}

# Check for touchscreen
$touchscreen = $false
try {
    $touch = Get-PnpDevice | Where-Object {
        $_.Class -eq "HIDClass" -and
        ($_.FriendlyName -match "Touch|HID-compliant touch" -or $_.HardwareID -match "VID_&.*&MI_01")
    }
    if ($touch) {
        $touchscreen = $true
    }
} catch {}

$testData.Display = @{
    GPU = $video.Name
    Resolution = "$($video.CurrentHorizontalResolution)x$($video.CurrentVerticalResolution)"
    RefreshRate = $video.CurrentRefreshRate
    VRAM = if ($video.AdapterRAM) { "$([math]::Round($video.AdapterRAM / 1GB, 2)) GB" } else { "N/A" }
    ScreenSize = $screenSizeInches
    Touchscreen = $touchscreen
}

$displayString = "$($video.CurrentHorizontalResolution)x$($video.CurrentVerticalResolution)@$($video.CurrentRefreshRate)"
$displayTier = Get-HardwareTier -ComponentType "Display" -ComponentName $displayString -Database $hardwareDB
$testData.Display.Tier = $displayTier.Tier
$testData.Display.TierScore = $displayTier.Score
$testData.Display.Category = $displayTier.Category

$globalScore += 5
$globalScoreMax += 5

Show-Progress -Status "Graphics Card..."
$gpuType = if ($video.Name -match "NVIDIA|AMD|Radeon|GeForce|RTX|GTX|Arc") { "Dedicated" } else { "Integrated" }
$gpuDeviceId = "Not Available"
try {
    $rawPnp = $null
    # Try PNPDeviceID first (most reliable hardware identifier for GPUs)
    if ($video.PNPDeviceID) { $rawPnp = $video.PNPDeviceID.Trim() }
    # Fallback: DeviceID property
    if (-not $rawPnp -and $video.DeviceID) { $rawPnp = $video.DeviceID.Trim() }
    if ($rawPnp) {
        # Extract clean VEN/DEV/SUBSYS/REV identifiers
        $venId = ""; $devId = ""; $subSys = ""; $revId = ""
        if ($rawPnp -match "VEN_([0-9A-Fa-f]+)") { $venId = $matches[1].ToUpper() }
        if ($rawPnp -match "DEV_([0-9A-Fa-f]+)") { $devId = $matches[1].ToUpper() }
        if ($rawPnp -match "SUBSYS_([0-9A-Fa-f]+)") { $subSys = $matches[1].ToUpper() }
        if ($rawPnp -match "REV_([0-9A-Fa-f]+)") { $revId = $matches[1].ToUpper() }
        if ($venId -and $devId) {
            $gpuDeviceId = "VEN:$venId  DEV:$devId"
            if ($subSys) { $gpuDeviceId += "  SUBSYS:$subSys" }
            if ($revId) { $gpuDeviceId += "  REV:$revId" }
        } else {
            $gpuDeviceId = $rawPnp
        }
    }
} catch {
    $gpuDeviceId = "Not Available"
}

$testData.GPU = @{
    Name = $video.Name
    Type = $gpuType
    VRAM = $testData.Display.VRAM
    Driver = $video.DriverVersion
    Status = $video.Status
    DeviceID = $gpuDeviceId
}

$gpuTier = Get-HardwareTier -ComponentType "GPU" -ComponentName $video.Name -Database $hardwareDB
$testData.GPU.Tier = $gpuTier.Tier
$testData.GPU.TierScore = $gpuTier.Score
$testData.GPU.Category = $gpuTier.Category
	try { if ($gpuTier.Specs) { $testData.GPU.Specs = $gpuTier.Specs } } catch { }
	try { if ($gpuTier.Benchmarks) { $testData.GPU.Benchmarks = $gpuTier.Benchmarks } } catch { }
	try { if ($gpuTier.Sources) { $testData.GPU.Sources = $gpuTier.Sources } } catch { }

	# Parse GPU display connector counts from dbgpu specs when available
	try {
	    $connStr = $null
	    if ($testData.GPU.Specs) {
	        try { $connStr = ("" + $testData.GPU.Specs.displayConnectors).Trim() } catch { $connStr = $null }
	    }
	    if ($connStr) {
	        $testData.GPU.DisplayConnectorCounts = Get-DisplayConnectorCounts -ConnectorString $connStr
	    }
	} catch { }

$gpuScore = if ($gpuType -eq "Dedicated") { 7 } else { 4 }
$globalScore += $gpuScore
$globalScoreMax += $gpuScore

Show-Progress -Status "Webcam Detection..."
# Detect webcam even if disabled
$cameras = Get-PnpDevice -FriendlyName *camera*,*webcam*,*imaging* | Where-Object {
    $_.Class -match "Camera|Image"
}

$testData.Webcam = @{
    Detected = if ($cameras.Count -gt 0) { $true } else { $false }
    Count = $cameras.Count
    Devices = $cameras | ForEach-Object {
        @{
            Name = $_.FriendlyName
            Status = $_.Status
            Enabled = ($_.Status -eq "OK")
        }
    }
}

# Only score webcam presence on portable systems (avoid penalizing desktops)
$webcamMax = if ($batteryData.Detected) { 3 } else { 0 }
$globalScore += if ($cameras.Count -gt 0) { $webcamMax } else { 0 }
$globalScoreMax += $webcamMax

Show-Progress -Status "Ports & Connectors..."

# ============================================================
# ENHANCED USB PORT DETECTION - More accurate counting
# ============================================================
$usbControllers = Get-CimInstance Win32_USBController -ErrorAction SilentlyContinue
$allUSBDevices = Get-PnpDevice -Class USB -ErrorAction SilentlyContinue

# Initialize USB port counts
$usbACount = 0
$usbCCount = 0
$thunderboltCount = 0

# Method 1: Detect USB-C and Thunderbolt ports specifically
# Only count actual USB-C controller/port devices, NOT USB 3.x devices
$usbCDevices = Get-PnpDevice -ErrorAction SilentlyContinue | Where-Object {
    # Strict matching for USB-C specific devices only
    ($_.FriendlyName -match "USB.*Type.?C.*Connector|USB-C.*Port|UCSI|USB Connector Manager" -or
     $_.FriendlyName -match "Thunderbolt.*Controller|Thunderbolt.*Port") -and
    $_.Status -eq "OK"
}

# Count Thunderbolt controllers (each typically represents 1-2 ports)
$thunderboltControllers = Get-PnpDevice -ErrorAction SilentlyContinue | Where-Object {
    $_.FriendlyName -match "Thunderbolt.*Controller|Thunderbolt.*Host" -and
    $_.Status -eq "OK"
}
$thunderboltCount = $thunderboltControllers.Count

# Count USB-C connectors (UCSI = USB Type-C Connector System Interface)
$ucsiDevices = Get-PnpDevice -ErrorAction SilentlyContinue | Where-Object {
    $_.FriendlyName -match "UCSI|USB Connector Manager|USB Type-C" -and
    $_.Status -eq "OK"
}

# USB-C count: UCSI devices indicate actual USB-C ports
# Don't count Thunderbolt separately if UCSI already includes them
if ($ucsiDevices.Count -gt 0) {
    $usbCCount = $ucsiDevices.Count
} elseif ($thunderboltCount -gt 0) {
    # Thunderbolt ports are also USB-C
    $usbCCount = $thunderboltCount
} else {
    # No USB-C detected
    $usbCCount = 0
}

# Method 2: Count USB-A ports by analyzing USB host controllers
# USB-A ports are typically on xHCI, EHCI, or UHCI controllers
$usbHostControllers = Get-CimInstance Win32_USBController -ErrorAction SilentlyContinue | Where-Object {
    $_.Name -match "xHCI|EHCI|UHCI|USB.*Host Controller|USB.*Controller"
}

# Get root hubs to estimate USB-A ports
$usbHubs = Get-CimInstance Win32_USBHub -ErrorAction SilentlyContinue
$rootHubs = $usbHubs | Where-Object { $_.Description -match "Root Hub" }

# For workstations/desktops, use a more generous estimate
# Check if this is a workstation (multiple controllers, Xeon CPU, etc.)
$isWorkstation = $false
try {
    $cpuInfo = Get-CimInstance Win32_Processor | Select-Object -First 1
    if ($cpuInfo.Name -match "Xeon|Threadripper|EPYC" -or $rootHubs.Count -gt 4) {
        $isWorkstation = $true
    }
} catch {}

if ($isWorkstation) {
    # Workstations typically have many USB-A ports
    # Each xHCI controller can support 4-8 ports, EHCI 2-4 ports
    $xhciCount = ($usbHostControllers | Where-Object { $_.Name -match "xHCI|USB 3" }).Count
    $ehciCount = ($usbHostControllers | Where-Object { $_.Name -match "EHCI|USB 2" }).Count

    # Conservative estimate: xHCI = 4 ports each, EHCI = 2 ports each
    $usbACount = ($xhciCount * 4) + ($ehciCount * 2)

    # Cap at reasonable maximum for workstations
    $usbACount = [math]::Min($usbACount, 12)
    $usbACount = [math]::Max($usbACount, 6)  # Workstations have at least 6 USB-A
} else {
    # Laptops: more conservative estimate
    if ($rootHubs.Count -gt 0) {
        if ($rootHubs.Count -eq 1) {
            $usbACount = 2
        } elseif ($rootHubs.Count -eq 2) {
            $usbACount = 3
        } elseif ($rootHubs.Count -eq 3) {
            $usbACount = 4
        } else {
            $usbACount = [math]::Min($rootHubs.Count + 2, 6)
        }
    } else {
        $usbACount = 3  # Default for laptops
    }
}

$usbPortCount = $usbACount + $usbCCount

# Check for USB-C Power Delivery
$usbCPD = $false
try {
    $pdDevices = Get-PnpDevice -ErrorAction SilentlyContinue | Where-Object {
        $_.FriendlyName -match "Power Delivery|USB-C.*PD|Thunderbolt.*Charging|UCSI.*PD"
    }
    if ($pdDevices.Count -gt 0) {
        $usbCPD = $true
    }
} catch {}

# Detect HDMI - Enhanced detection with multiple fallbacks
$hasHDMI = $false
try {
    # Method 1: Check video outputs
    $videoOutputs = Get-CimInstance Win32_VideoController
    foreach ($video in $videoOutputs) {
        if ($video.VideoProcessor -match "HDMI" -or $video.Name -match "HDMI" -or $video.Description -match "HDMI") {
            $hasHDMI = $true
            break
        }
    }

    # Method 2: Check PnP devices for HDMI
    if (-not $hasHDMI) {
        $hdmiDevices = Get-PnpDevice | Where-Object {
            $_.FriendlyName -match "HDMI" -or $_.HardwareID -match "HDMI"
        }
        if ($hdmiDevices.Count -gt 0) {
            $hasHDMI = $true
        }
    }

    # Method 3: Check monitor connections
    if (-not $hasHDMI) {
        $monitors = Get-CimInstance WmiMonitorConnectionParams -Namespace root\wmi -ErrorAction SilentlyContinue
        if ($monitors) {
            foreach ($mon in $monitors) {
                if ($mon.VideoOutputTechnology -eq 5) {  # 5 = HDMI
                    $hasHDMI = $true
                    break
                }
            }
        }
    }

    # Method 4: Heuristic - Most laptops from 2010+ have HDMI
    # Check CPU generation to estimate laptop age
    if (-not $hasHDMI -and $cpu.Name) {
        # Intel i3/i5/i7 4th gen (4xxx) and newer typically have HDMI
        # AMD Ryzen and newer typically have HDMI
        if ($cpu.Name -match "i[3579]-[4-9]\d{3}|i[3579]-1[0-4]\d{3}|Ryzen") {
            $hasHDMI = $true
        }
    }

    # Method 5: If laptop is not ultra-thin and has reasonable specs, likely has HDMI
    if (-not $hasHDMI) {
        # Check if laptop has dedicated GPU or decent integrated graphics
        $hasDecentGPU = $false
        foreach ($video in $videoOutputs) {
            if ($video.Name -match "NVIDIA|AMD|Radeon|HD Graphics [4-9]|Iris|UHD") {
                $hasDecentGPU = $true
                break
            }
        }
        if ($hasDecentGPU) {
            $hasHDMI = $true  # Laptops with decent GPUs almost always have HDMI
        }
    }
} catch {
    # Conservative fallback: assume HDMI exists on laptops (it's very common)
    $hasHDMI = $true
}

# Detect VGA port - Enhanced detection
$hasVGA = $false
try {
    # Method 1: Check PnP devices for VGA
    $vgaDevices = Get-PnpDevice | Where-Object {
        $_.FriendlyName -match "VGA|Video Graphics|D-Sub" -or
        $_.HardwareID -match "VGA"
    }
    if ($vgaDevices -and $vgaDevices.Count -gt 0) {
        $hasVGA = $true
    }

    # Method 2: Check video controller for VGA support
    if (-not $hasVGA) {
        $videoControllers = Get-CimInstance Win32_VideoController
        foreach ($video in $videoControllers) {
            if ($video.VideoProcessor -match "VGA" -or
                $video.AdapterCompatibility -match "VGA" -or
                $video.Name -match "VGA" -or
                $video.Description -match "VGA") {
                $hasVGA = $true
                break
            }
        }
    }

    # Method 3: Check monitor connections for VGA (analog)
    if (-not $hasVGA) {
        $monitors = Get-CimInstance WmiMonitorConnectionParams -Namespace root\wmi -ErrorAction SilentlyContinue
        if ($monitors) {
            foreach ($mon in $monitors) {
                # VideoOutputTechnology: 0 = HD15 (VGA), 1 = S-video, etc.
                if ($mon.VideoOutputTechnology -eq 0) {
                    $hasVGA = $true
                    break
                }
            }
        }
    }

    # Method 4: Heuristic based on laptop age
    # Laptops from 2008-2017 commonly had VGA
    if (-not $hasVGA -and $cpu.Name) {
        # Intel 2nd gen (2xxx) through 7th gen (7xxx) often had VGA
        if ($cpu.Name -match "i[3579]-[2-7]\d{3}[A-Z]*") {
            $hasVGA = $true
        }
    }

    # Method 5: If has HDMI and is older generation (pre-2018), likely has VGA too
    # Most business laptops from 2010-2017 had both HDMI and VGA
    if (-not $hasVGA -and $hasHDMI) {
        # Check if it's an older laptop (not 8th gen or newer)
        if ($cpu.Name -match "i[3579]-[2-7]\d{3}|AMD.*A[6-9]|AMD.*E[12]|Pentium|Celeron") {
            $hasVGA = $true  # Older laptops with HDMI typically also have VGA
        }
    }

    # Method 6: Check system model for business laptops (they often have VGA)
    if (-not $hasVGA) {
        $model = $computerInfo.CsModel
        if ($model -match "ThinkPad|Latitude|EliteBook|ProBook|Precision|Vostro") {
            # Business laptops often retained VGA longer
            $hasVGA = $true
        }
    }
} catch {
    $hasVGA = $false
}

# Detect Ethernet port - Enhanced detection
$hasEthernet = $false
try {
    # Method 1: Check all network adapters
    $allAdapters = Get-NetAdapter -ErrorAction SilentlyContinue
    $ethAdapter = $allAdapters | Where-Object {
        $_.InterfaceDescription -match "Ethernet|Gigabit|10/100|LAN|RJ45|Realtek.*PCIe GBE|Intel.*Ethernet" -and
        $_.InterfaceDescription -notmatch "Virtual|Wireless|WiFi|Bluetooth|Miniport"
    }

    if ($ethAdapter.Count -gt 0) {
        $hasEthernet = $true
    }

    # Method 2: Check PnP devices for Ethernet controller
    if (-not $hasEthernet) {
        $ethDevices = Get-PnpDevice -Class Net | Where-Object {
            $_.FriendlyName -match "Ethernet|Gigabit|10/100|LAN|Network.*Adapter" -and
            $_.FriendlyName -notmatch "Wireless|WiFi|Virtual|Bluetooth|Miniport"
        }
        if ($ethDevices.Count -gt 0) {
            $hasEthernet = $true
        }
    }

    # Method 3: Check CIM for network adapter
    if (-not $hasEthernet) {
        $netAdapters = Get-CimInstance Win32_NetworkAdapter | Where-Object {
            $_.Name -match "Ethernet|Gigabit|10/100|LAN|Realtek" -and
            $_.Name -notmatch "Wireless|WiFi|Virtual|Bluetooth|Miniport|802\.11"
        }
        if ($netAdapters.Count -gt 0) {
            $hasEthernet = $true
        }
    }
} catch {
    $hasEthernet = $false
}

	# Detect DisplayPort (best-effort)
	$hasDisplayPort = $false
	try {
		$monitors = Get-CimInstance WmiMonitorConnectionParams -Namespace root\wmi -ErrorAction SilentlyContinue
		if ($monitors) {
			foreach ($mon in $monitors) {
				# VideoOutputTechnology: 10 = DisplayPort (external), 11 = DisplayPort (embedded)
				if ($mon.VideoOutputTechnology -eq 10 -or $mon.VideoOutputTechnology -eq 11) {
					$hasDisplayPort = $true
					break
				}
			}
		}
		if (-not $hasDisplayPort) {
			$dpDevices = @(Get-PnpDevice -ErrorAction SilentlyContinue | Where-Object { $_.FriendlyName -match 'DisplayPort' })
			if ($dpDevices.Count -gt 0) { $hasDisplayPort = $true }
		}
	} catch {
		$hasDisplayPort = $false
	}

	$gpuDisplay = @{ HDMI = 0; DisplayPort = 0; DVI = 0; VGA = 0; USBC = 0; Total = 0; Source = "None" }
	try {
	    if ($testData.GPU -and $testData.GPU.DisplayConnectorCounts) { $gpuDisplay = $testData.GPU.DisplayConnectorCounts }
	} catch { }

	$testData.Ports = @{
    USB = @{
        Total = $usbPortCount
        USBA = $usbACount
        USBC = $usbCCount
        Thunderbolt = $thunderboltCount
        Controllers = $usbControllers.Count
    }
    USBC_PD = $usbCPD
    HDMI = $hasHDMI
    VGA = $hasVGA
    Ethernet = $hasEthernet
	    DisplayPort = $hasDisplayPort
	    DisplayOutputs = @{
	        HDMI = [int]$gpuDisplay.HDMI
	        DisplayPort = [int]$gpuDisplay.DisplayPort
	        DVI = [int]$gpuDisplay.DVI
	        VGA = [int]$gpuDisplay.VGA
	        USBC_DPAlt = [int]$gpuDisplay.USBC
	        Total = [int]$gpuDisplay.Total
	        Source = ("" + $gpuDisplay.Source)
	    }
}

$globalScore += 4
$globalScoreMax += 4

Show-Progress -Status "Keyboard Features..."

# Keyboard backlight detection - Fixed
$keyboardBacklight = $false
try {
    # Only check for actual keyboard backlight devices, NOT monitor brightness
    $backlightDevice = Get-PnpDevice | Where-Object {
        $_.FriendlyName -match "Keyboard.*Backlight|Keyboard.*Illumination|Keyboard.*Light" -and
        $_.FriendlyName -notmatch "Monitor|Display|Screen"
    }
    if ($backlightDevice -and $backlightDevice.Count -gt 0) {
        $keyboardBacklight = $true
    }

    # Check for keyboard backlight in WMI (not monitor brightness!)
    if (-not $keyboardBacklight) {
	        $kbBacklight = Get-CimInstance -Namespace root\wmi -ClassName MSI_Keyboard_Backlight -ErrorAction SilentlyContinue
        if ($kbBacklight) {
            $keyboardBacklight = $true
        }
    }

    # Check for gaming keyboard RGB control
    if (-not $keyboardBacklight) {
        $rgbDevice = Get-PnpDevice | Where-Object {
            $_.FriendlyName -match "RGB.*Keyboard|Gaming.*Keyboard.*Light|Illuminated Keyboard"
        }
        if ($rgbDevice -and $rgbDevice.Count -gt 0) {
            $keyboardBacklight = $true
        }
    }
} catch {}

# Keyboard layout check (Ctrl position)
$keyboardLayout = "Standard"
try {
    $kbDevices = Get-PnpDevice -Class Keyboard -Status OK -ErrorAction SilentlyContinue
    foreach ($kb in $kbDevices) {
        if ($kb.FriendlyName -match "ThinkPad|Dell|HP|Lenovo") {
            $keyboardLayout = "Standard (Ctrl bottom-left)"
            break
        }
    }
} catch {}

$testData.Keyboard = @{
    Backlight = $keyboardBacklight
    Layout = $keyboardLayout
    Count = $testData.InputDevices.Keyboards
}

Show-Progress -Status "Durability & Certifications..."

# Check for MIL-STD certification
$milStdCertified = $false
$certifications = @()

try {
    # Check BIOS/System info for certifications
    $systemInfo = Get-CimInstance Win32_ComputerSystem
    $biosInfo = Get-CimInstance Win32_BIOS

    $combinedInfo = "$($systemInfo.Model) $($systemInfo.Manufacturer) $($biosInfo.Version)"

    if ($combinedInfo -match "MIL-?STD|810G|810H|Military|Rugged") {
        $milStdCertified = $true
        $certifications += "MIL-STD-810G/H"
    }

    # Common rugged laptop brands
    if ($systemInfo.Model -match "ThinkPad.*T\d|ThinkPad.*X\d|ThinkPad.*P\d|Latitude.*Rugged|EliteBook|ProBook|ToughBook") {
        $certifications += "Business/Rugged Grade"
    }
} catch {}

$testData.Durability = @{
    MIL_STD_Certified = $milStdCertified
    Certifications = $certifications
    EstimatedLifespan = if ($milStdCertified) { "4-6 years" } else { "3-4 years" }
}

Show-Progress -Status "USB Power Delivery..."

# Check if USB ports can charge when laptop is off
$usbPowerWhenOff = $false
try {
    # This is usually a BIOS feature, hard to detect from Windows
    # Check for "Always On USB" or "PowerShare" features
    $usbFeatures = Get-PnpDevice | Where-Object {
        $_.FriendlyName -match "Always On|PowerShare|Charging Port"
    }

    if ($usbFeatures.Count -gt 0) {
        $usbPowerWhenOff = $true
    }
} catch {}

$testData.Features = @{
    USBPowerWhenOff = $usbPowerWhenOff
    USBC_PDCharging = $usbCPD
}

Show-Progress -Status "Calculating Performance Score..."

$weights = @{
    CPU = 0.30
    RAM = 0.20
    Storage = 0.15
    GPU = 0.20
    Display = 0.10
    Other = 0.05
}

$performanceScore = [math]::Round((
    ($testData.CPU.TierScore * $weights.CPU) +
    ($testData.Memory.TierScore * $weights.RAM) +
    ($testData.Storage.TierScore * $weights.Storage) +
    ($testData.GPU.TierScore * $weights.GPU) +
    ($testData.Display.TierScore * $weights.Display) +
    (50 * $weights.Other)
), 0)

$testData.PerformanceScore = $performanceScore
$testData.PerformanceTier = if ($performanceScore -ge 85) { "Flagship" }
    elseif ($performanceScore -ge 70) { "High Performance" }
    elseif ($performanceScore -ge 55) { "Mainstream" }
    elseif ($performanceScore -ge 40) { "Mid-Range" }
    elseif ($performanceScore -ge 25) { "Entry Level" }
    else { "Legacy" }

Show-Progress -Status "Generating Recommendations..."

$useCases = Get-UseCaseRecommendations -PerformanceScore $performanceScore -Database $upgradeDB
$testData.UseCases = $useCases

$currentSpecs = @{
    RAM = [math]::Round($totalRAM, 0)
    StorageType = $testData.Storage.MediaType
	    HasSSD = ($testData.Storage.SSDCount -gt 0)
	    HasNVMe = ($testData.Storage.NVMeCount -gt 0)
    StorageSpeed = $avgSpeed
    BatteryHealth = $batteryData.Health
    CPUAge = $testData.CPU.EstimatedAge
    PerformanceScore = $performanceScore
}

$upgrades = Get-UpgradeRecommendations -CurrentSpecs $currentSpecs -Database $upgradeDB
$testData.UpgradeRecommendations = $upgrades

Show-Progress -Status $(if ($batteryData.Detected) { "AC Adapter Health Test..." } else { "Power / PSU Info..." })
if ($batteryData.Detected) {
    $testData.AdapterTest = Test-AdapterHealth
} else {
    $testData.AdapterTest = Get-DesktopPowerInfo
}

Show-Progress -Status "Finalizing Report..."

#endregion

#region Calculate Final Scores

# Normalize the additive score into a real /100 so modern/new machines are not under-scored.
$testData.HealthScoreRaw = $globalScore
$testData.HealthScoreMax = $globalScoreMax

if (-not $globalScoreMax -or $globalScoreMax -le 0) {
    $globalScore = 0
} else {
    $globalScore = [math]::Round(($globalScore / $globalScoreMax) * 100, 0)
    $globalScore = [math]::Max(0, [math]::Min(100, $globalScore))
}

$testData.HealthScore = $globalScore

$overallHealthRating = if ($globalScore -ge 85) { "Excellent" }
    elseif ($globalScore -ge 70) { "Good" }
    elseif ($globalScore -ge 50) { "Fair" }
    else { "Needs Attention" }

#endregion

	$reportPath = Join-Path $outputDir "Diagnostic_Report_$timestamp.html"

# Generate HTML report

# Prepare HTML variables
$cpuScoreVal = $cpuScore
$cpuStatus = if ($avgLoad -lt 70) { "Good" } else { "Fair" }

$ramScoreVal = $ramScore
$ramStatus = if ($totalRAM -ge 8) { "Excellent" } elseif ($totalRAM -ge 4) { "Good" } else { "Low" }

$storageScoreVal = $storageScore
	$storageStatus = if ($testData.Storage.MediaType -match "(?i)SSD|NVMe") { "Excellent" } else { "Standard" }

$batteryScoreVal = if ($batteryData.Detected) { $batteryScore } else { 0 }
$batteryDetails = if ($batteryData.Detected) { "$($batteryData.Health)% Health" } else { "Not applicable" }

$cpuScoreMax = 7
$ramScoreMax = 7
$storageScoreMax = 10
$batteryScoreMax = if ($batteryData.Detected) { 8 } else { 0 }

$cpuScorePct = if ($cpuScoreMax -gt 0) { [math]::Round(($cpuScoreVal / $cpuScoreMax) * 100, 0) } else { 0 }
$ramScorePct = if ($ramScoreMax -gt 0) { [math]::Round(($ramScoreVal / $ramScoreMax) * 100, 0) } else { 0 }
$storageScorePct = if ($storageScoreMax -gt 0) { [math]::Round(($storageScoreVal / $storageScoreMax) * 100, 0) } else { 0 }
$batteryScorePct = if ($batteryScoreMax -gt 0) { [math]::Round(($batteryScoreVal / $batteryScoreMax) * 100, 0) } else { 0 }

$batteryBreakdownHtml = ""
if ($batteryScoreMax -gt 0) {
    $batteryBreakdownHtml = @"
                    <span class=\"component-name\">Battery</span>
                    <div class=\"component-bar\"><div class=\"component-bar-fill\" style=\"width: $batteryScorePct%;\"></div></div>
                    <span class=\"component-score\">$batteryScoreVal/$batteryScoreMax</span>
"@
}

$healthScoreNoteHtml = "<div style='margin-top:10px; font-size:12px; color:#7f8c8d;'>Points Earned: $($testData.HealthScoreRaw)/$($testData.HealthScoreMax). Overall Health Score = (Points Earned / Points Possible) × 100. Battery is only scored when present.</div>"

$tempScoreVal = $tempScore
$tempStatus = $testData.Temperature.Status

$gpuScoreVal = $gpuScore
$gpuStatus = if ($gpuType -eq "Dedicated") { "Dedicated" } else { "Integrated" }

$webcamScoreVal = 0
$webcamStatus = "Optional"
$webcamDetails = "Not scored on desktops"
if ($webcamMax -gt 0) {
    $webcamScoreVal = if ($testData.Webcam.Detected) { $webcamMax } else { 0 }
    $webcamStatus = if ($testData.Webcam.Detected) { "Detected" } else { "Not Found" }
    $webcamDetails = "$($testData.Webcam.Count) camera(s)"
}

$wifiScoreVal = 0
$wifiStatus = "Optional"
$wifiDetails = "N/A"
if ($wifiMax -gt 0) {
    $wifiScoreVal = if ($testData.Network.WiFi.Detected) { $wifiMax } else { 0 }
    $wifiStatus = if ($testData.Network.WiFi.Detected) { "Detected" } else { "Not Found" }
    $wifiDetails = if ($testData.Network.WiFi.Detected) { $testData.Network.WiFi.Name } else { "N/A" }
}

# Generate use cases HTML
$useCasesHTML = ""
if ($testData.UseCases.Suitable -and $testData.UseCases.Suitable.Count -gt 0) {
    $useCasesHTML += "<div class='use-case-section'><h3 style='color: #27ae60;'>+ Well Suited For:</h3><ul class='suitable'>"
    foreach ($useCase in $testData.UseCases.Suitable) {
        $useCasesHTML += "<li>$useCase</li>"
    }
    $useCasesHTML += "</ul></div>"
}

if ($testData.UseCases.Limited -and $testData.UseCases.Limited.Count -gt 0) {
    $useCasesHTML += "<div class='use-case-section'><h3 style='color: #f39c12;'>! Limited Performance For:</h3><ul class='limited'>"
    foreach ($useCase in $testData.UseCases.Limited) {
        $useCasesHTML += "<li>$useCase</li>"
    }
    $useCasesHTML += "</ul></div>"
}

if ($testData.UseCases.NotRecommended -and $testData.UseCases.NotRecommended.Count -gt 0) {
    $useCasesHTML += "<div class='use-case-section'><h3 style='color: #e74c3c;'>- Not Recommended For:</h3><ul class='not-recommended'>"
    foreach ($useCase in $testData.UseCases.NotRecommended) {
        $useCasesHTML += "<li>$useCase</li>"
    }
    $useCasesHTML += "</ul></div>"
}

# Generate upgrades HTML
$upgradesHTML = ""
if ($testData.UpgradeRecommendations -and $testData.UpgradeRecommendations.Count -gt 0) {
    foreach ($upgrade in $testData.UpgradeRecommendations) {
        $priority = if ($upgrade.Priority -eq 1) { "HIGH" } else { "MEDIUM" }
        $priorityColor = if ($upgrade.Priority -eq 1) { "#e74c3c" } else { "#f39c12" }

        $upgradesHTML += @"
<div class='upgrade-card'>
    <div class='upgrade-header'>
        <h3>$($upgrade.Component)</h3>
        <span class='priority-badge' style='background: $priorityColor;'>Priority: $priority</span>
    </div>
    <div class='upgrade-details'>
        <div class='upgrade-row'>
            <span class='upgrade-label'>Current:</span>
            <span class='upgrade-value'>$($upgrade.Current)</span>
        </div>
        <div class='upgrade-row'>
            <span class='upgrade-label'>Recommended:</span>
            <span class='upgrade-value' style='color: #27ae60; font-weight: 600;'>$($upgrade.Recommended)</span>
        </div>
        <div class='upgrade-row'>
            <span class='upgrade-label'>Cost:</span>
            <span class='upgrade-value'>$($upgrade.Cost)</span>
        </div>
        <div class='upgrade-row'>
            <span class='upgrade-label'>Performance Gain:</span>
            <span class='upgrade-value' style='color: #3498db; font-weight: 600;'>+$($upgrade.PerformanceGain)%</span>
        </div>
    </div>
    <p class='upgrade-description'>$($upgrade.Description)</p>
</div>
"@
    }
} else {
    $upgradesHTML = "<p style='text-align: center; color: #27ae60; font-size: 18px;'>No critical upgrades needed at this time.</p>"
}

# Generate HTML report
$htmlContent = @"
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Laptop Diagnostic Report - v15.0</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }

        :root {
            --primary-gradient: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            --secondary-gradient: linear-gradient(135deg, #11998e 0%, #38ef7d 100%);
            --accent-gradient: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
            --dark-gradient: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
            --card-shadow: 0 8px 32px rgba(0, 0, 0, 0.12);
            --hover-shadow: 0 16px 48px rgba(0, 0, 0, 0.2);
            --glass-bg: rgba(255, 255, 255, 0.95);
            --text-primary: #1a1a2e;
            --text-secondary: #6c757d;
        }

        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: var(--dark-gradient);
            background-attachment: fixed;
            padding: 30px;
            min-height: 100vh;
        }

        body::before {
            content: '';
            position: fixed;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            background:
                radial-gradient(circle at 20% 80%, rgba(102, 126, 234, 0.15) 0%, transparent 50%),
                radial-gradient(circle at 80% 20%, rgba(118, 75, 162, 0.15) 0%, transparent 50%),
                radial-gradient(circle at 40% 40%, rgba(240, 147, 251, 0.1) 0%, transparent 40%);
            pointer-events: none;
            z-index: -1;
        }

        .container {
            max-width: 1400px;
            margin: 0 auto;
            background: var(--glass-bg);
            border-radius: 24px;
            box-shadow: var(--hover-shadow);
            overflow: hidden;
            backdrop-filter: blur(10px);
            border: 1px solid rgba(255, 255, 255, 0.2);
        }

        .header {
            background: var(--primary-gradient);
            color: white;
            padding: 50px 40px;
            text-align: center;
            position: relative;
            overflow: hidden;
        }

        .header::before {
            content: '';
            position: absolute;
            top: -50%;
            left: -50%;
            width: 200%;
            height: 200%;
            background: radial-gradient(circle, rgba(255,255,255,0.1) 0%, transparent 60%);
            animation: shimmer 8s infinite linear;
        }

        @keyframes shimmer {
            0% { transform: rotate(0deg); }
            100% { transform: rotate(360deg); }
        }

        .header h1 {
            font-size: 42px;
            margin-bottom: 12px;
            font-weight: 700;
            letter-spacing: -0.5px;
            text-shadow: 0 2px 4px rgba(0,0,0,0.2);
            position: relative;
        }

        .header p {
            font-size: 16px;
            opacity: 0.9;
            position: relative;
        }

        .header .version-badge {
            display: inline-block;
            background: rgba(255,255,255,0.2);
            padding: 6px 16px;
            border-radius: 20px;
            font-size: 12px;
            margin-top: 15px;
            backdrop-filter: blur(5px);
            border: 1px solid rgba(255,255,255,0.3);
        }

        .dual-rating {
            display: grid;
            grid-template-columns: 1fr 1fr;
            gap: 30px;
            padding: 40px;
            background: linear-gradient(180deg, #f8f9fa 0%, #ffffff 100%);
        }

        @media (max-width: 768px) {
            .dual-rating {
                grid-template-columns: 1fr;
                padding: 20px;
            }
        }

        .rating-card {
            background: white;
            border-radius: 20px;
            padding: 35px;
            box-shadow: var(--card-shadow);
            transition: all 0.4s cubic-bezier(0.175, 0.885, 0.32, 1.275);
            border: 1px solid rgba(102, 126, 234, 0.1);
            position: relative;
            overflow: hidden;
        }

        .rating-card::before {
            content: '';
            position: absolute;
            top: 0;
            left: 0;
            right: 0;
            height: 4px;
            background: var(--primary-gradient);
        }

        .rating-card:hover {
            transform: translateY(-8px);
            box-shadow: var(--hover-shadow);
            border-color: rgba(102, 126, 234, 0.3);
        }

        .rating-card h2 {
            font-size: 22px;
            margin-bottom: 10px;
            color: var(--text-primary);
            font-weight: 700;
        }

        .rating-card .subtitle {
            font-size: 14px;
            color: var(--text-secondary);
            margin-bottom: 25px;
        }

        .score-display {
            font-size: 72px;
            font-weight: 800;
            margin: 25px 0;
            background: var(--primary-gradient);
            -webkit-background-clip: text;
            -webkit-text-fill-color: transparent;
            background-clip: text;
            letter-spacing: -2px;
        }

        .rating-label {
            font-size: 26px;
            font-weight: 700;
            color: var(--text-primary);
            margin-bottom: 20px;
        }

        .progress-bar {
            width: 100%;
            height: 12px;
            background: linear-gradient(90deg, #e8eaed 0%, #f1f3f4 100%);
            border-radius: 6px;
            overflow: hidden;
            box-shadow: inset 0 2px 4px rgba(0,0,0,0.06);
        }

        .progress-fill {
            height: 100%;
            background: var(--primary-gradient);
            border-radius: 6px;
            transition: width 1.2s cubic-bezier(0.4, 0, 0.2, 1);
            box-shadow: 0 2px 8px rgba(102, 126, 234, 0.4);
        }

        .progress-fill.excellent { background: linear-gradient(90deg, #10b981 0%, #34d399 100%); }
        .progress-fill.good { background: linear-gradient(90deg, #3b82f6 0%, #60a5fa 100%); }
        .progress-fill.fair { background: linear-gradient(90deg, #f59e0b 0%, #fbbf24 100%); }
        .progress-fill.poor { background: linear-gradient(90deg, #ef4444 0%, #f87171 100%); }

        .component-breakdown {
            display: grid;
            grid-template-columns: auto 1fr auto;
            gap: 12px;
            margin-top: 25px;
            font-size: 14px;
        }

        .component-name {
            color: var(--text-primary);
            font-weight: 600;
        }

        .component-bar {
            height: 8px;
            background: #ecf0f1;
            border-radius: 4px;
            align-self: center;
        }

        .component-bar-fill {
            height: 100%;
            background: #667eea;
            border-radius: 4px;
        }

        .component-score {
            color: #7f8c8d;
            font-weight: 600;
        }

        .tabs {
            display: flex;
            flex-wrap: wrap;
            background: var(--dark-gradient);
            padding: 8px 10px;
            gap: 6px;
            justify-content: center;
        }

        .tab-button {
            background: rgba(255,255,255,0.08);
            border: none;
            color: rgba(255,255,255,0.8);
            padding: 10px 16px;
            cursor: pointer;
            font-size: 13px;
            font-weight: 600;
            transition: all 0.3s ease;
            border-radius: 8px;
            white-space: nowrap;
            position: relative;
        }

        .tab-button:hover {
            color: white;
            background: rgba(255,255,255,0.15);
            transform: translateY(-1px);
        }

        .tab-button.active {
            color: white;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            box-shadow: 0 2px 8px rgba(102, 126, 234, 0.4);
        }

        .tab-content {
            display: none;
            padding: 35px;
            animation: fadeIn 0.4s ease-out;
        }

        .tab-content.active {
            display: block;
        }

        @keyframes fadeIn {
            from { opacity: 0; transform: translateY(15px); }
            to { opacity: 1; transform: translateY(0); }
        }

        .cards {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
            gap: 24px;
        }

        .card {
            background: white;
            padding: 24px;
            border-radius: 16px;
            border-left: 4px solid #667eea;
            box-shadow: 0 4px 12px rgba(0,0,0,0.05);
            transition: all 0.3s ease;
        }

        .card:hover {
            box-shadow: 0 8px 24px rgba(0,0,0,0.1);
            transform: translateY(-2px);
        }

        .card h3 {
            color: var(--text-primary);
            margin-bottom: 18px;
            font-size: 17px;
            font-weight: 700;
            display: flex;
            align-items: center;
            gap: 8px;
        }

        .card h3::before {
            content: '';
            width: 8px;
            height: 8px;
            background: var(--primary-gradient);
            border-radius: 50%;
        }

        .card-row {
            display: flex;
            justify-content: space-between;
            align-items: center;
            padding: 10px 0;
            border-bottom: 1px solid #f1f3f4;
        }

        .card-row:last-child {
            border-bottom: none;
        }

        .label {
            color: var(--text-secondary);
            font-size: 14px;
            font-weight: 500;
        }

        .value {
            color: var(--text-primary);
            font-weight: 700;
            font-size: 14px;
            text-align: right;
            max-width: 60%;
            word-break: break-word;
        }

        .status-badge {
            display: inline-flex;
            align-items: center;
            gap: 6px;
            padding: 6px 14px;
            border-radius: 25px;
            font-size: 12px;
            font-weight: 700;
            text-transform: uppercase;
            letter-spacing: 0.5px;
        }

        .status-excellent {
            background: linear-gradient(135deg, #d4edda 0%, #c3e6cb 100%);
            color: #155724;
            box-shadow: 0 2px 8px rgba(21, 87, 36, 0.2);
        }
        .status-good {
            background: linear-gradient(135deg, #cce5ff 0%, #b8daff 100%);
            color: #004085;
            box-shadow: 0 2px 8px rgba(0, 64, 133, 0.2);
        }
        .status-fair {
            background: linear-gradient(135deg, #fff3cd 0%, #ffeeba 100%);
            color: #856404;
            box-shadow: 0 2px 8px rgba(133, 100, 4, 0.2);
        }
        .status-poor {
            background: linear-gradient(135deg, #f8d7da 0%, #f5c6cb 100%);
            color: #721c24;
            box-shadow: 0 2px 8px rgba(114, 28, 36, 0.2);
        }

        .test-section {
            background: white;
            padding: 28px;
            border-radius: 16px;
            margin-bottom: 24px;
            box-shadow: 0 4px 12px rgba(0,0,0,0.05);
            border: 1px solid #f1f3f4;
        }

        .test-section h3 {
            color: var(--text-primary);
            margin-bottom: 20px;
            font-weight: 700;
        }

        .use-case-section {
            margin: 24px 0;
            padding: 20px;
            background: #fafbfc;
            border-radius: 12px;
        }

        .use-case-section h3 {
            margin-bottom: 15px;
            font-size: 18px;
            font-weight: 700;
            color: var(--text-primary);
        }

        .use-case-section ul {
            list-style: none;
            padding-left: 0;
        }

        .use-case-section li {
            padding: 10px 0 10px 30px;
            position: relative;
            font-size: 14px;
            line-height: 1.6;
        }

        .suitable li:before { content: '+'; position: absolute; left: 0; color: #27ae60; font-weight: bold; }
        .limited li:before { content: '!'; position: absolute; left: 0; color: #f39c12; font-weight: bold; }
        .not-recommended li:before { content: '-'; position: absolute; left: 0; color: #e74c3c; font-weight: bold; }

        .upgrade-card {
            background: white;
            border: 2px solid #ecf0f1;
            border-radius: 10px;
            padding: 20px;
            margin-bottom: 20px;
        }

        .upgrade-header {
            display: flex;
            justify-content: space-between;
            align-items: center;
            margin-bottom: 15px;
        }

        .upgrade-header h3 {
            color: #2c3e50;
            font-size: 18px;
        }

        .priority-badge {
            padding: 6px 12px;
            border-radius: 20px;
            color: white;
            font-size: 12px;
            font-weight: 600;
        }

        .upgrade-details {
            background: #f8f9fa;
            padding: 15px;
            border-radius: 8px;
            margin-bottom: 15px;
        }

        .upgrade-row {
            display: flex;
            justify-content: space-between;
            padding: 6px 0;
        }

        .upgrade-label {
            color: #7f8c8d;
            font-size: 14px;
        }

        .upgrade-value {
            color: #2c3e50;
            font-weight: 600;
            font-size: 14px;
        }

        .upgrade-description {
            color: #34495e;
            font-size: 14px;
            line-height: 1.6;
            font-style: italic;
        }

        @media print {
            .tabs, .tab-button {
                display: none;
            }
            .tab-content {
                display: block !important;
                page-break-inside: avoid;
            }
        }

        @media (max-width: 1200px) {
            .cards {
                grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
                gap: 16px;
            }
        }

        @media (max-width: 768px) {
            .container {
                margin: 10px;
                padding: 16px;
                border-radius: 16px;
            }

            .header {
                padding: 24px 16px;
            }

            .header h1 {
                font-size: 22px;
            }

            .dual-rating {
                grid-template-columns: 1fr;
                gap: 16px;
            }

            .rating-card {
                padding: 20px;
            }

            .score-display {
                font-size: 42px;
            }

            .cards {
                grid-template-columns: 1fr;
                gap: 12px;
            }

            .card {
                padding: 16px;
                border-radius: 12px;
            }

            .card h3 {
                font-size: 15px;
                margin-bottom: 12px;
            }

            .card-row {
                padding: 8px 0;
                flex-wrap: wrap;
                gap: 4px;
            }

            .card-row .label {
                font-size: 13px;
                flex: 1 1 100%;
            }

            .card-row .value {
                font-size: 14px;
                flex: 1 1 100%;
                text-align: left;
                font-weight: 600;
            }

            .tabs {
                flex-wrap: wrap;
                gap: 4px;
                padding: 6px;
            }

            .tab-button {
                font-size: 11px;
                padding: 8px 12px;
                flex: 1 1 auto;
                text-align: center;
                min-width: 70px;
            }

            .test-section {
                padding: 16px;
            }

            .version-badge {
                font-size: 11px;
                padding: 4px 10px;
            }

            .report-footer {
                padding: 24px 16px;
            }

            .footer-content {
                flex-direction: column;
                text-align: center;
                gap: 16px;
            }

            .footer-brand {
                justify-content: center;
            }

            .footer-title {
                font-size: 16px;
            }

            .footer-info {
                font-size: 13px;
            }
        }

        @media (max-width: 480px) {
            .container {
                margin: 8px;
                padding: 12px;
            }

            .header h1 {
                font-size: 18px;
            }

            .tabs {
                gap: 3px;
                padding: 4px;
            }

            .tab-button {
                font-size: 10px;
                padding: 6px 8px;
                min-width: 55px;
            }

            .score-display {
                font-size: 36px;
            }

            .card {
                padding: 14px;
            }

            .card-row {
                padding: 6px 0;
            }

            .component-breakdown {
                grid-template-columns: 1fr;
                gap: 8px;
            }

            .component-name, .component-score {
                font-size: 11px;
            }
        }

        /* Powered By styling */
        .powered-by {
            font-size: 16px !important;
            margin-top: 8px !important;
            background: var(--primary-gradient);
            -webkit-background-clip: text;
            -webkit-text-fill-color: transparent;
            background-clip: text;
        }

        /* Interactive test styles */
        .keyboard-grid {
            margin: 20px 0;
        }

        .keyboard-row {
            margin-bottom: 15px;
            border-left: 3px solid #667eea;
            padding-left: 15px;
        }

        .row-label {
            font-size: 11px;
            color: #7f8c8d;
            margin-bottom: 5px;
            font-weight: 600;
        }

        .keys-container {
            display: flex;
            flex-wrap: wrap;
            gap: 5px;
        }

        .key {
            background: #ecf0f1;
            border: 2px solid #bdc3c7;
            border-radius: 5px;
            padding: 12px 8px;
            text-align: center;
            font-size: 11px;
            font-weight: 600;
            color: #2c3e50;
            min-width: 45px;
            min-height: 45px;
            display: flex;
            align-items: center;
            justify-content: center;
            transition: all 0.2s;
        }

        .key.pressed {
            background: #27ae60;
            color: white;
            border-color: #229954;
            transform: scale(0.95);
        }

        .key.numpad-key {
            background: #e8f4fd;
            border-color: #a8d4f0;
        }

        .key.numpad-key.pressed {
            background: #27ae60;
            color: white;
            border-color: #229954;
        }

        .touchpad-test {
            background: white;
            border: 2px solid #34495e;
            border-radius: 10px;
            height: 400px;
            cursor: crosshair;
            position: relative;
        }

        .test-button {
            background: #667eea;
            color: white;
            border: none;
            padding: 12px 24px;
            border-radius: 8px;
            cursor: pointer;
            font-size: 14px;
            font-weight: 600;
            margin: 5px;
            transition: all 0.3s;
        }

        .test-button:hover {
            background: #764ba2;
            transform: translateY(-2px);
        }

        .status-grid {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
            gap: 10px;
            margin: 20px 0;
        }

        .status-item {
            background: #f8f9fa;
            padding: 15px;
            border-radius: 8px;
            text-align: center;
        }

        .status-item .label {
            font-size: 12px;
            color: #7f8c8d;
            margin-bottom: 5px;
        }

        .status-item .value {
            font-size: 16px;
            font-weight: 600;
        }

        /* Microphone/Webcam Test Styles */
        .mic-select {
            width: 100%;
            padding: 12px;
            border: 2px solid #ddd;
            border-radius: 8px;
            font-size: 14px;
            background: white;
            cursor: pointer;
        }

        .mic-select:focus {
            border-color: #667eea;
            outline: none;
        }

        .mic-level-container {
            width: 100%;
            height: 40px;
            background: #ecf0f1;
            border-radius: 8px;
            overflow: hidden;
            position: relative;
        }

        .mic-level-bar {
            height: 100%;
            width: 0%;
            background: linear-gradient(90deg, #27ae60 0%, #f1c40f 50%, #e74c3c 100%);
            border-radius: 8px;
            transition: width 0.1s ease;
        }

        /* Footer Styles */
        .report-footer {
            background: var(--dark-gradient);
            color: white;
            padding: 40px;
            margin-top: 0;
        }

        .footer-content {
            display: flex;
            justify-content: space-between;
            align-items: center;
            flex-wrap: wrap;
            gap: 20px;
            max-width: 1200px;
            margin: 0 auto;
        }

        .footer-brand {
            display: flex;
            align-items: center;
            gap: 12px;
        }

        .footer-logo-icon {
            width: 32px;
            height: 32px;
            background: var(--primary-gradient);
            border-radius: 8px;
            display: flex;
            align-items: center;
            justify-content: center;
            animation: pulse 2s infinite;
        }

        .footer-logo-icon::before {
            content: '';
            width: 16px;
            height: 16px;
            background: white;
            clip-path: polygon(50% 0%, 0% 100%, 100% 100%);
        }

        @keyframes pulse {
            0%, 100% { opacity: 1; transform: scale(1); }
            50% { opacity: 0.8; transform: scale(0.95); }
        }

        .footer-title {
            font-size: 20px;
            font-weight: 700;
            background: var(--primary-gradient);
            -webkit-background-clip: text;
            -webkit-text-fill-color: transparent;
            background-clip: text;
        }

        .serial-number {
            font-size: 14px;
            margin-top: 10px;
            padding: 8px 20px;
            background: rgba(255,255,255,0.15);
            border-radius: 20px;
            display: inline-block;
            backdrop-filter: blur(5px);
        }

        .serial-number strong {
            color: #fff;
            font-weight: 600;
            letter-spacing: 1px;
        }

        .serial-value {
            font-family: 'Courier New', Consolas, monospace;
            font-size: 11px;
            letter-spacing: 0.3px;
            background: linear-gradient(135deg, rgba(52,152,219,0.06), rgba(155,89,182,0.06));
            border: 1px solid rgba(52,152,219,0.15);
            padding: 2px 8px;
            border-radius: 4px;
            display: inline-block;
            color: var(--text-secondary);
            word-break: break-all;
            overflow-wrap: anywhere;
            max-width: 100%;
            line-height: 1.6;
        }

        .serial-label {
            font-size: 9px;
            text-transform: uppercase;
            letter-spacing: 1px;
            color: rgba(127,140,141,0.7);
            margin-bottom: 1px;
            margin-right: 4px;
            display: inline-block;
            vertical-align: middle;
        }

        .serial-row {
            display: flex;
            justify-content: space-between;
            align-items: flex-start;
            padding: 6px 0;
            border-top: 1px dashed rgba(0,0,0,0.06);
        }

        .module-detail-row {
            padding: 10px 14px;
            margin: 6px 0;
            background: rgba(0,0,0,0.018);
            border-radius: 8px;
            border-left: 3px solid rgba(52,152,219,0.3);
            overflow: hidden;
        }

        .module-detail-row .mod-header {
            font-weight: 600;
            font-size: 13px;
            margin-bottom: 5px;
            color: var(--text-primary);
        }

        .module-detail-row .mod-specs {
            font-size: 12px;
            color: var(--text-secondary);
            margin-bottom: 6px;
        }

        .module-detail-row .mod-serial {
            font-size: 11px;
            color: #7f8c8d;
            display: flex;
            flex-wrap: wrap;
            gap: 6px 12px;
            align-items: center;
        }

        .footer-info {
            text-align: center;
            color: rgba(255,255,255,0.7);
            font-size: 14px;
        }

        .footer-info p {
            margin: 4px 0;
        }

        .footer-info strong {
            color: white;
            font-weight: 700;
        }

        .footer-links a {
            display: inline-flex;
            align-items: center;
            gap: 8px;
            color: white;
            text-decoration: none;
            padding: 10px 20px;
            background: rgba(255,255,255,0.1);
            border-radius: 25px;
            transition: all 0.3s ease;
            font-weight: 600;
        }

        .footer-links a:hover {
            background: rgba(255,255,255,0.2);
            transform: translateY(-2px);
        }

        @media (max-width: 768px) {
            .footer-content {
                flex-direction: column;
                text-align: center;
            }
        }
    </style>
</head>
<body>
    <div class="container">
	        <div class="header">
	            <h1>Hardware Diagnostic Report</h1>
	            <p>Complete System Analysis - Generated: $timestampDisplay</p>
            <p>System: $($testData.System.Manufacturer) $($testData.System.Model)</p>
            <p class="serial-number">Serial Number: <strong>$($testData.System.SerialNumber)</strong></p>
        </div>

        <div class="dual-rating">
            <div class="rating-card">
                <h2>Health Score</h2>
                <p class="subtitle">Current condition and functionality</p>
                <div class="score-display">$globalScore/100</div>
                <div class="rating-label">$overallHealthRating</div>
                <div class="progress-bar">
                    <div class="progress-fill" style="width: $globalScore%;"></div>
                </div>
                <div class="component-breakdown">
                    <span class="component-name">CPU</span>
	                    <div class="component-bar"><div class="component-bar-fill" style="width: $cpuScorePct%;"></div></div>
	                    <span class="component-score">$cpuScoreVal/$cpuScoreMax</span>

                    <span class="component-name">RAM</span>
	                    <div class="component-bar"><div class="component-bar-fill" style="width: $ramScorePct%;"></div></div>
	                    <span class="component-score">$ramScoreVal/$ramScoreMax</span>

                    <span class="component-name">Storage</span>
	                    <div class="component-bar"><div class="component-bar-fill" style="width: $storageScorePct%;"></div></div>
	                    <span class="component-score">$storageScoreVal/$storageScoreMax</span>

$batteryBreakdownHtml
                </div>
	                $healthScoreNoteHtml
            </div>

            <div class="rating-card">
                <h2>Performance Score</h2>
                <p class="subtitle">Compared to 2025 standards</p>
                <div class="score-display">$performanceScore/100</div>
                <div class="rating-label">$($testData.PerformanceTier)</div>
                <div class="progress-bar">
                    <div class="progress-fill" style="width: $performanceScore%;"></div>
                </div>
                <div class="component-breakdown">
                    <span class="component-name">CPU ($($testData.CPU.Tier))</span>
                    <div class="component-bar"><div class="component-bar-fill" style="width: $($testData.CPU.TierScore)%;"></div></div>
                    <span class="component-score">$($testData.CPU.TierScore)/100</span>

                    <span class="component-name">RAM ($($testData.Memory.Tier))</span>
                    <div class="component-bar"><div class="component-bar-fill" style="width: $($testData.Memory.TierScore)%;"></div></div>
                    <span class="component-score">$($testData.Memory.TierScore)/100</span>

                    <span class="component-name">Storage ($($testData.Storage.Tier))</span>
                    <div class="component-bar"><div class="component-bar-fill" style="width: $($testData.Storage.TierScore)%;"></div></div>
                    <span class="component-score">$($testData.Storage.TierScore)/100</span>

                    <span class="component-name">GPU ($($testData.GPU.Tier))</span>
                    <div class="component-bar"><div class="component-bar-fill" style="width: $($testData.GPU.TierScore)%;"></div></div>
                    <span class="component-score">$($testData.GPU.TierScore)/100</span>
                </div>
            </div>
        </div>

        <div class="tabs">
            <button class="tab-button active" onclick="openTab('overview', event)">Overview</button>
            <button class="tab-button" onclick="openTab('battery', event)">Battery</button>
            <button class="tab-button" onclick="openTab('adapter', event)">Adapter</button>
            <button class="tab-button" onclick="openTab('hardware', event)">Hardware</button>
            <button class="tab-button" onclick="openTab('keyboard', event)">Keyboard</button>
            <button class="tab-button" onclick="openTab('touchpad', event)">Touchpad</button>
            <button class="tab-button" onclick="openTab('display', event)">Display</button>
            <button class="tab-button" onclick="openTab('audio', event)">Audio</button>
            <button class="tab-button" onclick="openTab('microphone', event)">Microphone</button>
            <button class="tab-button" onclick="openTab('webcam', event)">Webcam</button>
        </div>

        <div id="overview" class="tab-content active">
            <h2 style="margin-bottom: 20px;">System Overview</h2>

            <div class="cards">
                <div class="card">
                    <h3>System Information</h3>
                    <div class="card-row">
                        <span class="label">Manufacturer</span>
                        <span class="value">$($testData.System.Manufacturer)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Model</span>
                        <span class="value">$($testData.System.Model)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Operating System</span>
                        <span class="value">$($testData.System.OS)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">BIOS Version</span>
                        <span class="value">$($testData.System.BIOSVersion)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Activation Status</span>
                        <span class="value" style="color: $(if ($testData.System.ActivationStatus -eq 'Activated') { '#27ae60' } elseif ($testData.System.ActivationStatus -eq 'Unknown') { '#7f8c8d' } else { '#e74c3c' });">$($testData.System.ActivationStatus)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">License Type</span>
                        <span class="value">$($testData.System.LicenseType)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Motherboard</span>
                        <span class="value">$($testData.System.MotherboardManufacturer) $($testData.System.MotherboardProduct)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Motherboard S/N</span>
                        <span class="value"><span class="serial-value">$($testData.System.MotherboardSerial)</span></span>
                    </div>
                </div>

                <div class="card">
                    <h3>Processor</h3>
                    <div class="card-row">
                        <span class="label">Model</span>
                        <span class="value">$($testData.CPU.Name)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Cores / Threads</span>
                        <span class="value">$($testData.CPU.Cores) / $($testData.CPU.Threads)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Speed</span>
                        <span class="value">$($testData.CPU.Speed) MHz</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Current Load</span>
                        <span class="value">$($testData.CPU.CurrentLoad)%</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Benchmark</span>
                        <span class="value">$($testData.CPU.BenchmarkOps) ops/sec</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Tier</span>
                        <span class="value">$($testData.CPU.Tier) ($($testData.CPU.TierScore)/100)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Age</span>
                        <span class="value">~$($testData.CPU.EstimatedAge) years old</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Processor ID</span>
                        <span class="value"><span class="serial-value">$($testData.CPU.ProcessorId)</span></span>
                    </div>
                </div>

                <div class="card">
                    <h3>Memory (RAM)</h3>
                    <div class="card-row">
                        <span class="label">Total RAM</span>
                        <span class="value">$($testData.Memory.Total)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Type</span>
                        <span class="value">$($testData.Memory.Type)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Speed</span>
                        <span class="value">$($testData.Memory.Speed)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Modules</span>
                        <span class="value">$($testData.Memory.Modules)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Tier</span>
                        <span class="value">$($testData.Memory.Tier) ($($testData.Memory.TierScore)/100)</span>
                    </div>
			    $(
			        $memExtra = ""
			        try {
			            if ($testData.Memory.Category) { $memExtra += "<div class='card-row'><span class='label'>Category</span><span class='value'>$($testData.Memory.Category)</span></div>" }
			        } catch { }
			        try {
			            if ($testData.Memory.Sources) {
			                $src = @($testData.Memory.Sources) -join ', '
			                if (-not [string]::IsNullOrWhiteSpace($src)) { $memExtra += "<div class='card-row'><span class='label'>Sources</span><span class='value'>$src</span></div>" }
			            }
			        } catch { }
			        try {
			            if ($testData.Memory.Specs -and $testData.Memory.Specs.DDRType) { $memExtra += "<div class='card-row'><span class='label'>PassMark DDR Type</span><span class='value'>$($testData.Memory.Specs.DDRType)</span></div>" }
			        } catch { }
			        try {
			            if ($testData.Memory.Benchmarks) {
			                $lat = $null; $rd = $null; $wr = $null
			                try { $lat = $testData.Memory.Benchmarks.latencyNs } catch { $lat = $null }
			                try { $rd = $testData.Memory.Benchmarks.readGBs } catch { $rd = $null }
			                try { $wr = $testData.Memory.Benchmarks.writeGBs } catch { $wr = $null }
			                if ($lat -or $rd -or $wr) {
			                    $memExtra += "<div class='card-row'><span class='label'>PassMark (Derived)</span><span class='value'>Read $rd GB/s &middot; Write $wr GB/s &middot; Latency $lat ns</span></div>"
			                }
			            }
			        } catch { }
			        $memExtra
			    )
                    $(
                        $ramModuleHtml = ""
                        if ($testData.Memory.ModuleDetails -and $testData.Memory.ModuleDetails.Count -gt 0) {
                            $ramModuleHtml += "<div class='card-row' style='border-top: 1px solid rgba(255,255,255,0.1); padding-top: 8px; margin-top: 4px;'><span class='label' style='font-weight: 600;'>Module Details</span><span class='value'></span></div>"
                            foreach ($mod in $testData.Memory.ModuleDetails) {
                                $ramModuleHtml += "<div class='module-detail-row'><div class='mod-header'>$($mod.Slot)</div><div class='mod-specs'>$($mod.Manufacturer) &middot; $($mod.Capacity) &middot; $($mod.Speed)</div><div class='mod-serial'><span class='serial-label'>Part Number</span> <span class='serial-value'>$($mod.PartNumber)</span> &nbsp; <span class='serial-label'>Serial</span> <span class='serial-value'>$($mod.SerialNumber)</span></div></div>"
                            }
                        }
                        $ramModuleHtml
                    )
                </div>

                <div class="card">
                    <h3>Storage ($($testData.Storage.TotalDisks) Drive$(if($testData.Storage.TotalDisks -gt 1){'s'}))</h3>
                    <div class="card-row">
                        <span class="label">Total Capacity</span>
                        <span class="value">$($testData.Storage.TotalStorageGB) GB</span>
                    </div>
                    <div class="card-row">
                        <span class="label">NVMe SSDs</span>
                        <span class="value">$($testData.Storage.NVMeCount)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">SATA SSDs</span>
                        <span class="value">$($testData.Storage.SSDCount - $testData.Storage.NVMeCount)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">HDDs</span>
                        <span class="value">$($testData.Storage.HDDCount)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Boot Drive</span>
                        <span class="value">$($testData.Storage.Model) ($($testData.Storage.DetailedType))</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Boot Drive Size</span>
                        <span class="value">$($testData.Storage.Size)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Boot Drive S/N</span>
                        <span class="value"><span class="serial-value">$($testData.Storage.SerialNumber)</span></span>
                    </div>
                    <div class="card-row">
                        <span class="label">Health</span>
                        <span class="value">$($testData.Storage.Health)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Read Speed</span>
                        <span class="value">$($testData.Storage.ReadSpeed)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Write Speed</span>
                        <span class="value">$($testData.Storage.WriteSpeed)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Tier</span>
                        <span class="value">$($testData.Storage.Tier) ($($testData.Storage.TierScore)/100)</span>
                    </div>
			    $(
			        $stExtra = ""
			        try {
			            if ($testData.Storage.Category) { $stExtra += "<div class='card-row'><span class='label'>Category</span><span class='value'>$($testData.Storage.Category)</span></div>" }
			        } catch { }
			        try {
			            if ($testData.Storage.Sources) {
			                $src = @($testData.Storage.Sources) -join ', '
			                if (-not [string]::IsNullOrWhiteSpace($src)) { $stExtra += "<div class='card-row'><span class='label'>Sources</span><span class='value'>$src</span></div>" }
			            }
			        } catch { }
			        try {
			            if ($testData.Storage.Specs -and $testData.Storage.Specs.Type) { $stExtra += "<div class='card-row'><span class='label'>PassMark Type</span><span class='value'>$($testData.Storage.Specs.Type)</span></div>" }
			            if ($testData.Storage.Specs -and $testData.Storage.Specs.Size) { $stExtra += "<div class='card-row'><span class='label'>PassMark Size</span><span class='value'>$($testData.Storage.Specs.Size)</span></div>" }
			        } catch { }
			        try {
			            if ($testData.Storage.Benchmarks) {
			                $dm = $null
			                try { $dm = $testData.Storage.Benchmarks.passMarkDiskMark } catch { $dm = $null }
			                if ($dm) { $stExtra += "<div class='card-row'><span class='label'>PassMark Disk Mark</span><span class='value'>$dm</span></div>" }
			            }
			        } catch { }
			        $stExtra
			    )
                    $(
                        $allDisksHtml = ""
                        foreach ($disk in $testData.Storage.AllDisks) {
                            $bootLabel = if ($disk.IsBootDrive) { " [BOOT]" } else { "" }
                            $diskSn = Get-SanitizedSerial $disk.SerialNumber
                            $allDisksHtml += "<div class='module-detail-row'><div class='mod-header'>$($disk.MediaType) &middot; $($disk.Model)$bootLabel</div><div class='mod-specs'>$($disk.SizeFormatted)</div><div class='mod-serial'><span class='serial-label'>Serial</span> <span class='serial-value'>$diskSn</span></div></div>"
                        }
                        $allDisksHtml
                    )
                </div>

                <div class="card">
                    <h3>Graphics</h3>
                    <div class="card-row">
                        <span class="label">GPU</span>
                        <span class="value">$($testData.GPU.Name)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Type</span>
                        <span class="value">$($testData.GPU.Type)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">VRAM</span>
                        <span class="value">$($testData.GPU.VRAM)</span>
                    </div>
	                    $(
	                        try {
	                            $s = $testData.GPU.Specs
	                            $b = $testData.GPU.Benchmarks
	                            $rows = ""
	
	                            if ($s) {
	                                try { if ($s.manufacturer) { $rows += "<div class='card-row'><span class='label'>Manufacturer</span><span class='value'>$($s.manufacturer)</span></div>" } } catch { }
	                                try { if ($s.architecture) { $rows += "<div class='card-row'><span class='label'>Architecture</span><span class='value'>$($s.architecture)</span></div>" } } catch { }
	                                try { if ($s.processNodeNm) { $rows += "<div class='card-row'><span class='label'>Process Node</span><span class='value'>$($s.processNodeNm) nm</span></div>" } } catch { }
	                                try { if ($s.shaderUnits) { $rows += "<div class='card-row'><span class='label'>Shader Units</span><span class='value'>$($s.shaderUnits)</span></div>" } } catch { }
	                                try { if ($s.tensorCores) { $rows += "<div class='card-row'><span class='label'>Tensor Cores</span><span class='value'>$($s.tensorCores)</span></div>" } } catch { }
	                                try { if ($s.rayTracingCores) { $rows += "<div class='card-row'><span class='label'>RT Cores</span><span class='value'>$($s.rayTracingCores)</span></div>" } } catch { }
	                                try { if ($s.tdpW) { $rows += "<div class='card-row'><span class='label'>TDP</span><span class='value'>$($s.tdpW) W</span></div>" } } catch { }

	                                try {
	                                    if ($s.memoryType -or $s.memorySizeGB -or $s.memoryBandwidthGBs -or $s.memoryBusBits) {
	                                        $memParts = @()
	                                        if ($s.memorySizeGB) { $memParts += ("$($s.memorySizeGB) GB") }
	                                        if ($s.memoryType) { $memParts += ("$($s.memoryType)") }
	                                        if ($s.memoryBusBits) { $memParts += ("$($s.memoryBusBits)-bit") }
	                                        if ($s.memoryBandwidthGBs) { $memParts += ("$([math]::Round([double]$s.memoryBandwidthGBs, 1)) GB/s") }
	                                        if ($memParts.Count -gt 0) {
			                                            # Avoid non-ASCII separator to prevent charset mojibake (e.g., "·") in some viewers.
			                                            $rows += "<div class='card-row'><span class='label'>Memory</span><span class='value'>$($memParts -join ' &middot; ')</span></div>"
	                                        }
	                                    }
	                                } catch { }

	                                try { if ($s.displayConnectors) { $rows += "<div class='card-row'><span class='label'>Display Connectors</span><span class='value'>$($s.displayConnectors)</span></div>" } } catch { }
	                            }

	                            if ($b) {
	                                try { if ($b.passMarkG3d) { $rows += "<div class='card-row'><span class='label'>PassMark G3D</span><span class='value'>$($b.passMarkG3d)</span></div>" } } catch { }
	                                try { if ($b.dbgpuSingleFloatTflops) { $rows += "<div class='card-row'><span class='label'>Single-Precision</span><span class='value'>$($b.dbgpuSingleFloatTflops) TFLOPS</span></div>" } } catch { }
	                            }

	                            $rows
	                        } catch { "" }
	                    )
                    <div class="card-row">
                        <span class="label">Driver</span>
                        <span class="value">$($testData.GPU.Driver)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Tier</span>
                        <span class="value">$($testData.GPU.Tier) ($($testData.GPU.TierScore)/100)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Device ID</span>
                        <span class="value"><span class="serial-value">$($testData.GPU.DeviceID)</span></span>
                    </div>
                </div>

                <div class="card">
                    <h3>Display</h3>
                    <div class="card-row">
                        <span class="label">Resolution</span>
                        <span class="value">$($testData.Display.Resolution)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Refresh Rate</span>
                        <span class="value">$($testData.Display.RefreshRate) Hz</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Screen Size</span>
                        <span class="value" style="color: #27ae60; font-weight: bold;">$($testData.Display.ScreenSize)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Touchscreen</span>
                        <span class="value">$(if ($testData.Display.Touchscreen) { 'Yes' } else { 'No' })</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Tier</span>
                        <span class="value">$($testData.Display.Tier) ($($testData.Display.TierScore)/100)</span>
                    </div>
                </div>

                <div class="card">
                    <h3>Network & Connectivity</h3>
                    <div class="card-row">
                        <span class="label">WiFi</span>
                        <span class="value" style="color: $(if ($testData.Network.WiFi.Detected) { '#27ae60' } else { '#e74c3c' });">$(if ($testData.Network.WiFi.Detected) { 'Detected' } else { 'Not Found' })</span>
                    </div>
"@

if ($testData.Network.WiFi.Detected) {
    $htmlContent += @"
                    <div class="card-row">
                        <span class="label">WiFi Adapter</span>
                        <span class="value">$($testData.Network.WiFi.Name)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Link Speed</span>
                        <span class="value">$($testData.Network.WiFi.Speed)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Status</span>
                        <span class="value">$($testData.Network.WiFi.Status)</span>
                    </div>
"@
    if ($testData.Network.WiFi.SignalStrength -ne "N/A") {
        $htmlContent += @"
                    <div class="card-row">
                        <span class="label">Signal Strength</span>
                        <span class="value">$($testData.Network.WiFi.SignalStrength)</span>
                    </div>
"@
    }
}

$htmlContent += @"
                    <div class="card-row">
                        <span class="label">Bluetooth</span>
                        <span class="value">$(if ($testData.Network.Bluetooth.Detected) { 'Detected' } else { 'Not Found' })</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Ethernet</span>
                        <span class="value">$(if ($testData.Ports.Ethernet) { 'Yes' } else { 'No' })</span>
                    </div>
                </div>

                <div class="card">
                    <h3>Ports & Connectors</h3>
                    <div class="card-row">
                        <span class="label">Total USB Ports</span>
                        <span class="value">$($testData.Ports.USB.Total) (estimated)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">USB Type-A</span>
                        <span class="value">$($testData.Ports.USB.USBA) (estimated)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">USB Type-C</span>
                        <span class="value" style="color: $(if ($testData.Ports.USB.USBC -gt 0) { '#27ae60' } else { '#7f8c8d' });">$($testData.Ports.USB.USBC)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Thunderbolt</span>
                        <span class="value" style="color: $(if ($testData.Ports.USB.Thunderbolt -gt 0) { '#27ae60' } else { '#7f8c8d' });">$($testData.Ports.USB.Thunderbolt)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">USB-C PD</span>
                        <span class="value">$(if ($testData.Ports.USBC_PD) { 'Supported' } else { 'Not Detected' })</span>
                    </div>
                    <div class="card-row">
                        <span class="label">HDMI</span>
                        <span class="value">$(if ($testData.Ports.HDMI) { 'Yes' } else { 'Not Detected' })</span>
                    </div>
                    <div class="card-row">
                        <span class="label">VGA</span>
                        <span class="value">$(if ($testData.Ports.VGA) { 'Yes' } else { 'Not Detected' })</span>
                    </div>
						<div class="card-row">
							<span class="label">DisplayPort</span>
							<span class="value">$(if ($testData.Ports.DisplayPort) { 'Yes' } else { 'Not Detected' })</span>
						</div>
                    <div class="card-row">
                        <span class="label">Ethernet Port</span>
                        <span class="value">$(if ($testData.Ports.Ethernet) { 'Yes' } else { 'Not Detected' })</span>
                    </div>
	                    $(
	                        try {
	                            $do = $testData.Ports.DisplayOutputs
	                            if ($do -and ([int]$do.Total -gt 0)) {
	                                $h = "<div class='card-row' style='margin-top: 10px; border-top: 1px solid rgba(255,255,255,0.1); padding-top: 10px;'><span class='label' style='font-weight: bold;'>GPU Display Outputs</span><span class='value'>$(if ($do.Source) { $do.Source } else { 'Estimated' })</span></div>"
	                                $h += "<div class='card-row'><span class='label'>Total</span><span class='value'>$([int]$do.Total)</span></div>"
	                                if ([int]$do.HDMI -gt 0) { $h += "<div class='card-row'><span class='label'>HDMI</span><span class='value'>$([int]$do.HDMI)</span></div>" }
	                                if ([int]$do.DisplayPort -gt 0) { $h += "<div class='card-row'><span class='label'>DisplayPort</span><span class='value'>$([int]$do.DisplayPort)</span></div>" }
	                                if ([int]$do.DVI -gt 0) { $h += "<div class='card-row'><span class='label'>DVI</span><span class='value'>$([int]$do.DVI)</span></div>" }
	                                if ([int]$do.VGA -gt 0) { $h += "<div class='card-row'><span class='label'>VGA</span><span class='value'>$([int]$do.VGA)</span></div>" }
	                                if ([int]$do.USBC_DPAlt -gt 0) { $h += "<div class='card-row'><span class='label'>USB-C (DP Alt)</span><span class='value'>$([int]$do.USBC_DPAlt)</span></div>" }
	                                $h
	                            }
	                        } catch { "" }
	                    )
                </div>

				<div class="card">
					<h3>Motherboard Expansion Slots</h3>
					<div class="card-row">
						<span class="label">RAM Slots</span>
						<span class="value">$($testData.MotherboardSlots.RAMSlotsUsed) / $($testData.MotherboardSlots.RAMSlotsTotal) used</span>
					</div>
					<div class="card-row">
						<span class="label">M.2 / NVMe</span>
						<span class="value">$($testData.MotherboardSlots.M2SlotsUsed) used (slots: $($testData.MotherboardSlots.M2SlotsTotal) est.)</span>
					</div>
					<div class="card-row">
						<span class="label">PCI/PCIe Slots</span>
						<span class="value">$($testData.MotherboardSlots.PCIeSlotsTotal) detected</span>
					</div>
					<div class="card-row">
						<span class="label">SATA</span>
						<span class="value">$($testData.MotherboardSlots.SATADrivesUsed) drives (ports: $($testData.MotherboardSlots.SATAPortsEstimated) est.)</span>
					</div>
				</div>

                <div class="card">
                    <h3>Keyboard & Input</h3>
                    <div class="card-row">
                        <span class="label">Keyboard Backlight</span>
                        <span class="value" style="color: $(if ($testData.Keyboard.Backlight) { '#27ae60' } else { '#7f8c8d' });">$(if ($testData.Keyboard.Backlight) { 'Detected' } else { 'Not Detected' })</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Layout</span>
                        <span class="value">$($testData.Keyboard.Layout)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Keyboards</span>
                        <span class="value">$($testData.Keyboard.Count)</span>
                    </div>
                </div>

                <div class="card">
                    <h3>Webcam</h3>
                    <div class="card-row">
                        <span class="label">Status</span>
                        <span class="value" style="color: $(if ($testData.Webcam.Detected) { '#27ae60' } else { '#e74c3c' });">$(if ($testData.Webcam.Detected) { 'Detected' } else { 'Not Found' })</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Count</span>
                        <span class="value">$($testData.Webcam.Count)</span>
                    </div>
"@

if ($testData.Webcam.Detected -and $testData.Webcam.Devices) {
    foreach ($cam in $testData.Webcam.Devices) {
        $htmlContent += @"
                    <div class="card-row">
                        <span class="label">$($cam.Name)</span>
                        <span class="value" style="color: $(if ($cam.Enabled) { '#27ae60' } else { '#f39c12' });">$(if ($cam.Enabled) { 'Enabled' } else { 'Disabled' })</span>
                    </div>
"@
    }
}

$htmlContent += @"
                </div>

                <div class="card">
                    <h3>Durability & Certifications</h3>
                    <div class="card-row">
                        <span class="label">MIL-STD Certified</span>
                        <span class="value" style="color: $(if ($testData.Durability.MIL_STD_Certified) { '#27ae60' } else { '#7f8c8d' });">$(if ($testData.Durability.MIL_STD_Certified) { 'Yes' } else { 'No/Unknown' })</span>
                    </div>
"@

if ($testData.Durability.Certifications -and $testData.Durability.Certifications.Count -gt 0) {
    foreach ($cert in $testData.Durability.Certifications) {
        $htmlContent += @"
                    <div class="card-row">
                        <span class="label">Certification</span>
                        <span class="value">$cert</span>
                    </div>
"@
    }
}

$htmlContent += @"
                    <div class="card-row">
                        <span class="label">Est. Lifespan</span>
                        <span class="value">$($testData.Durability.EstimatedLifespan)</span>
                    </div>
                </div>

                <div class="card">
                    <h3>Special Features</h3>
                    <div class="card-row">
                        <span class="label">USB Power When Off</span>
                        <span class="value">$(if ($testData.Features.USBPowerWhenOff) { 'Supported' } else { 'Unknown' })</span>
                    </div>
                    <div class="card-row">
                        <span class="label">USB-C PD Charging</span>
                        <span class="value">$(if ($testData.Features.USBC_PDCharging) { 'Supported' } else { 'No' })</span>
                    </div>
                </div>
            </div>

            <div class="test-section">
                <h3>Recommended Use Cases</h3>
                <p style="margin-bottom: 20px; color: #7f8c8d;">Based on your Performance Score of <strong>$performanceScore/100 ($($testData.PerformanceTier))</strong>, here's what your laptop can handle:</p>

                $useCasesHTML
            </div>

            <div class="test-section">
                <h3>Upgrade Recommendations</h3>
                <p style="margin-bottom: 20px; color: #7f8c8d;">These upgrades could improve your system's performance:</p>

                $upgradesHTML
            </div>
        </div>

        <div id="battery" class="tab-content">
            <h2 style="margin-bottom: 20px;">Battery Analysis</h2>

"@

if ($testData.Battery.Detected) {
    # Color coding: Green (>80%), Yellow (60-80%), Orange (40-60%), Red (<40%)
    $healthColor = if ($testData.Battery.Health -gt 80) { '#27ae60' }
                   elseif ($testData.Battery.Health -ge 60) { '#f1c40f' }
                   elseif ($testData.Battery.Health -ge 40) { '#e67e22' }
                   else { '#e74c3c' }

    $healthStatus = if ($testData.Battery.Health -gt 80) { 'Excellent' }
                    elseif ($testData.Battery.Health -ge 60) { 'Good' }
                    elseif ($testData.Battery.Health -ge 40) { 'Fair' }
                    else { 'Poor' }

	# Optional diagnostics (helps troubleshoot 0% health / missing capacities)
	$batteryDebugHtml = ""
	if ($testData.Battery.Debug -and $testData.Battery.Debug.Count -gt 0) {
	    $batteryDebugLines = ($testData.Battery.Debug | ForEach-Object { "<li style='margin:6px 0;'>$($_)</li>" }) -join ""
	    $batteryDebugHtml = @"
			<div class="test-section" style="margin-top: 18px;">
				<details style="background: rgba(255,255,255,0.85); border: 1px solid rgba(0,0,0,0.08); border-radius: 12px; padding: 12px 16px;">
					<summary style="cursor:pointer; font-weight:600; color:#2c3e50;">Battery Diagnostics (click to expand)</summary>
					<div style="margin-top:10px; color:#2c3e50; font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace; font-size: 12px;">
						<ul style="padding-left: 18px; margin: 0;">$batteryDebugLines</ul>
					</div>
				</details>
			</div>
"@
	}

    $htmlContent += @"
            <div class="test-section">
                <!-- Prominent Battery Health Display -->
                <div style="text-align: center; padding: 30px; background: linear-gradient(135deg, rgba(255,255,255,0.9) 0%, rgba(248,249,250,0.9) 100%); border-radius: 16px; border: 3px solid $healthColor; margin-bottom: 30px; box-shadow: 0 4px 20px rgba(0,0,0,0.1);">
                    <div style="font-size: 72px; font-weight: bold; color: $healthColor; line-height: 1;">$($testData.Battery.Health)%</div>
                    <div style="font-size: 24px; color: #2c3e50; margin-top: 10px; font-weight: 600;">Battery Health</div>
                    <div style="font-size: 18px; color: $healthColor; margin-top: 5px; font-weight: 500;">$healthStatus</div>
                    <div class="progress-bar" style="margin: 20px auto; max-width: 400px;">
                        <div class="progress-fill" style="width: $($testData.Battery.Health)%; background: $healthColor;"></div>
                    </div>
                    <div style="font-size: 12px; color: #7f8c8d; margin-top: 15px; font-family: monospace; background: #f0f0f0; padding: 8px 16px; border-radius: 8px; display: inline-block;">
                        Health = (Full Charge Capacity / Design Capacity) x 100 = ($($testData.Battery.FullChargeCapacity) / $($testData.Battery.DesignCapacity)) x 100 = $($testData.Battery.Health)%
                    </div>
                </div>

	                $batteryDebugHtml

                <div class="cards">
                    <div class="card">
                        <h3>Capacity Information</h3>
                        <div class="card-row">
                            <span class="label">Design Capacity</span>
                            <span class="value">$($testData.Battery.DesignCapacity) mWh</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Full Charge Capacity</span>
                            <span class="value">$($testData.Battery.FullChargeCapacity) mWh</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Current Charge</span>
                            <span class="value">$($testData.Battery.CurrentCharge)%</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Health Percentage</span>
                            <span class="value" style="color: $healthColor; font-weight: bold;">$($testData.Battery.Health)%</span>
                        </div>
                    </div>

                    <div class="card">
                        <h3>Battery Details</h3>
                        <div class="card-row">
                            <span class="label">Status</span>
                            <span class="value">$($testData.Battery.Status)</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Chemistry</span>
                            <span class="value">$($testData.Battery.Chemistry)</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Voltage</span>
                            <span class="value">$($testData.Battery.Voltage)</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Current Rate</span>
                            <span class="value">$($testData.Battery.CurrentRate)</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Cycle Count</span>
                            <span class="value">$($testData.Battery.CycleCount)</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Manufacturer</span>
                            <span class="value">$($testData.Battery.Manufacturer)</span>
                        </div>
                    </div>
                </div>
            </div>
"@
} else {
    $htmlContent += @"
            <div class="test-section">
                <h3>No Battery Detected</h3>
                <p>This system does not have a battery installed or the battery is not detected. This is normal for desktop computers.</p>
            </div>
"@
}

$htmlContent += @"
	        </div>

	        <div id="adapter" class="tab-content">
"@

	if ($batteryData.Detected) {
	    $htmlContent += @"
	            <h2 style="margin-bottom: 20px;">AC Adapter / Charger Health Test</h2>

	            <div class="test-section">
"@

	    if ($testData.AdapterTest.Connected) {
    # Determine health color
    $healthColor = switch ($testData.AdapterTest.Health) {
        "Excellent" { '#27ae60' }
        "Good" { '#3498db' }
        "Fair" { '#f39c12' }
        default { '#e74c3c' }
    }

    $htmlContent += @"
                <div class="card" style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; margin-bottom: 20px;">
                    <h3 style="color: white;">Overall Adapter Health</h3>
                    <div style="text-align: center; padding: 20px 0;">
                        <div style="font-size: 48px; font-weight: bold;">$($testData.AdapterTest.Health)</div>
                        <div style="font-size: 16px; margin-top: 10px; opacity: 0.9;">10-second comprehensive test completed</div>
                    </div>
                </div>

                <h3>Power Delivery Analysis</h3>
                <div class="cards">
                    <div class="card">
                        <h3>Battery Voltage</h3>
                        <div class="card-row">
                            <span class="label">Current</span>
                            <span class="value">$($testData.AdapterTest.Voltage.Current) V</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Average</span>
                            <span class="value">$($testData.AdapterTest.Voltage.Avg) V</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Min / Max</span>
                            <span class="value">$($testData.AdapterTest.Voltage.Min) - $($testData.AdapterTest.Voltage.Max) V</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Stability</span>
                            <span class="value" style="color: $healthColor; font-weight: bold;">$($testData.AdapterTest.Voltage.Stability)</span>
                        </div>
                    </div>

                    <div class="card">
                        <h3>Charging Power</h3>
                        <div class="card-row">
                            <span class="label">Current</span>
                            <span class="value">$($testData.AdapterTest.Power.Current) W</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Average</span>
                            <span class="value">$($testData.AdapterTest.Power.Avg) W</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Min / Max</span>
                            <span class="value">$($testData.AdapterTest.Power.Min) - $($testData.AdapterTest.Power.Max) W</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Estimated Rating</span>
                            <span class="value" style="font-weight: bold;">$($testData.AdapterTest.Power.EstimatedRating)</span>
                        </div>
                    </div>
"@

    if ($testData.AdapterTest.Current.Avg -gt 0) {
        $htmlContent += @"
                    <div class="card">
                        <h3>Current Draw</h3>
                        <div class="card-row">
                            <span class="label">Current</span>
                            <span class="value">$($testData.AdapterTest.Current.Current) A</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Average</span>
                            <span class="value">$($testData.AdapterTest.Current.Avg) A</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Min / Max</span>
                            <span class="value">$($testData.AdapterTest.Current.Min) - $($testData.AdapterTest.Current.Max) A</span>
                        </div>
                    </div>
"@
    }

    $htmlContent += @"
                </div>

                <h3>Charging Performance</h3>
                <div class="cards">
"@

    if ($testData.AdapterTest.ChargingRate.IsCharging) {
        $htmlContent += @"
                    <div class="card">
                        <h3>Charging Rate</h3>
                        <div class="card-row">
                            <span class="label">Current Rate</span>
                            <span class="value">$($testData.AdapterTest.ChargingRate.Current) W</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Average Rate</span>
                            <span class="value">$($testData.AdapterTest.ChargingRate.Avg) W</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Min / Max</span>
                            <span class="value">$($testData.AdapterTest.ChargingRate.Min) - $($testData.AdapterTest.ChargingRate.Max) W</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Status</span>
                            <span class="value" style="color: #27ae60; font-weight: bold;">[OK] Charging</span>
                        </div>
                    </div>
"@
    } else {
        # Check if battery is at 100% - not charging is normal in this case
        $batteryLevel = $testData.AdapterTest.BatteryLevel.Start
        $isFullyCharged = $batteryLevel -ge 99

        if ($isFullyCharged) {
            $htmlContent += @"
                    <div class="card">
                        <h3>Charging Status</h3>
                        <div class="card-row">
                            <span class="label">Status</span>
                            <span class="value" style="color: #27ae60; font-weight: bold;">[OK] Fully Charged</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Battery Level</span>
                            <span class="value">$($batteryLevel)%</span>
                        </div>
                        <div style="margin-top: 10px; padding: 10px; background: #e8f5e9; border-radius: 5px; border-left: 3px solid #27ae60;">
                            <p style="font-size: 13px; color: #27ae60; margin: 0;">Battery is fully charged. Not charging is normal when battery is at 100%.</p>
                        </div>
                    </div>
"@
        } else {
            $htmlContent += @"
                    <div class="card">
                        <h3>Charging Status</h3>
                        <div class="card-row">
                            <span class="label">Status</span>
                            <span class="value" style="color: #e74c3c; font-weight: bold;">[X] Not Charging</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Battery Level</span>
                            <span class="value">$($batteryLevel)%</span>
                        </div>
                        <div style="margin-top: 10px; padding: 10px; background: #fee; border-radius: 5px; border-left: 3px solid #e74c3c;">
                            <p style="font-size: 13px; color: #c0392b; margin: 0;">Adapter is connected but battery is not charging at $($batteryLevel)%. This could indicate an issue with the adapter, cable, or charging port.</p>
                        </div>
                    </div>
"@
        }
    }

    $htmlContent += @"
                    <div class="card">
                        <h3>Battery Level Change</h3>
                        <div class="card-row">
                            <span class="label">Start Level</span>
                            <span class="value">$($testData.AdapterTest.BatteryLevel.Start)%</span>
                        </div>
                        <div class="card-row">
                            <span class="label">End Level</span>
                            <span class="value">$($testData.AdapterTest.BatteryLevel.End)%</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Delta (10s)</span>
                            <span class="value">$($testData.AdapterTest.BatteryLevel.Delta)%</span>
                        </div>
                    </div>
                </div>
"@

    if ($testData.AdapterTest.Issues.Count -gt 0) {
        $htmlContent += @"
                <h3>Issues Detected</h3>
                <div style="background: #fee; border-left: 3px solid #e74c3c; padding: 15px; border-radius: 5px; margin-bottom: 20px;">
"@
        foreach ($issue in $testData.AdapterTest.Issues) {
            $htmlContent += @"
                    <div style="margin-bottom: 8px; color: #c0392b;">
                        <span style="font-weight: bold;">[!]</span> $issue
                    </div>
"@
        }
        $htmlContent += @"
                </div>
"@
    }

    $htmlContent += @"
                <h3>Recommendations</h3>
                <div style="background: #e8f5e9; border-left: 3px solid #27ae60; padding: 15px; border-radius: 5px;">
"@
    foreach ($recommendation in $testData.AdapterTest.Recommendations) {
        $htmlContent += @"
                    <div style="margin-bottom: 8px; color: #27ae60;">
                        <span style="font-weight: bold;">[OK]</span> $recommendation
                    </div>
"@
    }
    $htmlContent += @"
                </div>
"@

    # Display notes if available
    if ($testData.AdapterTest.Notes -and $testData.AdapterTest.Notes.Count -gt 0) {
        $htmlContent += @"
                <h3>Important Notes</h3>
                <div style="background: #e7f3ff; border-left: 3px solid #2196f3; padding: 15px; border-radius: 5px; margin-bottom: 20px;">
"@
        foreach ($note in $testData.AdapterTest.Notes) {
            $htmlContent += @"
                    <div style="margin-bottom: 8px; color: #1565c0; font-size: 13px;">
                        <span style="font-weight: bold;">*</span> $note
                    </div>
"@
        }
        $htmlContent += @"
                </div>
"@
    }

    $htmlContent += @"
                <div style="margin-top: 20px; padding: 15px; background: #f8f9fa; border-radius: 5px;">
                    <h4 style="font-size: 14px; color: #2c3e50; margin-bottom: 10px;">Understanding Adapter Health:</h4>
                    <ul style="font-size: 13px; color: #34495e; line-height: 1.6; margin: 0; padding-left: 20px;">
                        <li><strong>Voltage Stability:</strong> Good adapters maintain stable voltage within 3-5% variance</li>
                        <li><strong>Power Output:</strong> Should match or exceed the adapter's rated wattage during charging</li>
                        <li><strong>Charging Rate:</strong> Healthy adapters charge at consistent rates without significant drops</li>
                        <li><strong>Typical Ratings:</strong> Laptops use 45W (ultrabooks), 65W (standard), 90W+ (gaming/workstations)</li>
                    </ul>
                </div>
"@

	    } else {
    $htmlContent += @"
                <div class="card" style="background: #fff3cd; border-left: 3px solid #ffc107;">
                    <h3>Adapter Not Connected</h3>
                    <p style="color: #856404; margin: 10px 0;">The AC adapter is not currently connected to the laptop.</p>
                    <p style="color: #856404; margin: 10px 0; font-size: 13px;">To perform the comprehensive adapter health test, please:</p>
                    <ol style="color: #856404; margin: 10px 0 10px 20px; font-size: 13px; line-height: 1.6;">
                        <li>Connect the AC adapter to your laptop</li>
                        <li>Ensure the charging indicator light is on</li>
                        <li>Run the diagnostic tool again</li>
                    </ol>
                </div>

                <div style="margin-top: 20px; padding: 15px; background: #e7f3ff; border-radius: 5px; border-left: 3px solid #2196f3;">
                    <h4 style="font-size: 14px; color: #0d47a1; margin-bottom: 10px;">What the Adapter Test Checks:</h4>
                    <ul style="font-size: 13px; color: #1565c0; line-height: 1.6; margin: 0; padding-left: 20px;">
                        <li>Voltage stability and fluctuations over 10 seconds</li>
                        <li>Power delivery capacity and consistency</li>
                        <li>Charging rate and efficiency</li>
                        <li>Battery charging behavior</li>
                        <li>Adapter health assessment with recommendations</li>
                    </ul>
                </div>
"@
	    }
	} else {
	    $htmlContent += @"
	            <h2 style="margin-bottom: 20px;">Power Supply (PSU) / Power Information</h2>
	            <div class="test-section">
	                <div class="card" style="background: linear-gradient(135deg, #2c3e50 0%, #4b79a1 100%); color: white; margin-bottom: 20px;">
	                    <h3 style="color: white;">Desktop Power Overview</h3>
	                    <p style="opacity: 0.9; margin: 10px 0;">Windows usually cannot read internal PSU wattage/health directly. Below is the best available system power information.</p>
	                </div>

	                <div class="cards">
	                    <div class="card">
	                        <h3>Active Power Plan</h3>
	                        <div class="card-row"><span class="label">Plan</span><span class="value">$($testData.AdapterTest.ActivePowerPlan)</span></div>
	                        <div class="card-row"><span class="label">GUID</span><span class="value">$($testData.AdapterTest.ActivePowerPlanGuid)</span></div>
	                        <div class="card-row"><span class="label">Source</span><span class="value">$($testData.AdapterTest.ActivePowerPlanSource)</span></div>
	                    </div>
	                    <div class="card">
	                        <h3>UPS / Battery-like Device</h3>
	                        <div class="card-row"><span class="label">Detected</span><span class="value">$([string]$testData.AdapterTest.UPSDetected)</span></div>
	                        <div class="card-row"><span class="label">Name</span><span class="value">$($testData.AdapterTest.UPSName)</span></div>
	                    </div>
		                    <div class="card">
		                        <h3>PSU Wattage (Rated)</h3>
		                        <div class="card-row"><span class="label">Wattage</span><span class="value">$($testData.AdapterTest.PsuWattage)</span></div>
		                        <div class="card-row"><span class="label">Source</span><span class="value">$($testData.AdapterTest.PsuWattageSource)</span></div>
		                        <div style="margin-top: 10px; font-size: 12px; color: #7f8c8d; line-height: 1.5;">
		                            If this shows <strong>N/A</strong>, Windows couldn't read the PSU's label wattage. Verify from the PSU sticker/spec sheet.
		                        </div>
		                    </div>
		                    <div class="card">
		                        <h3>Live Power Sensors</h3>
		                        <div class="card-row"><span class="label">Provider</span><span class="value">$($testData.AdapterTest.SensorProvider)</span></div>
		                        <div class="card-row"><span class="label">Power Draw</span><span class="value">$($testData.AdapterTest.PowerDrawWatts)</span></div>
		                        <div class="card-row"><span class="label">CPU Package</span><span class="value">$($testData.AdapterTest.CpuPackagePowerWatts)</span></div>
		                        <div class="card-row"><span class="label">GPU</span><span class="value">$($testData.AdapterTest.GpuPowerWatts)</span></div>
		                        <div class="card-row"><span class="label">Source</span><span class="value">$($testData.AdapterTest.PowerDrawSource)</span></div>
		                        <div style="margin-top: 10px; font-size: 12px; color: #7f8c8d; line-height: 1.5;">
		                            This is <strong>current power draw</strong> (if available), not the PSU's rated wattage.
		                        </div>
		                    </div>
		                    <div class="card">
		                        <h3>Fan Speeds</h3>
		                        <div class="card-row"><span class="label">Top Fans</span><span class="value">$(if ($testData.AdapterTest.FanReadings -and $testData.AdapterTest.FanReadings.Count -gt 0) { (@($testData.AdapterTest.FanReadings) -join '<br/>') } else { 'N/A' })</span></div>
		                        <div style="margin-top: 10px; font-size: 12px; color: #7f8c8d; line-height: 1.5;">
		                            If this shows <strong>N/A</strong>, your system isn't exposing fan sensors to Windows. LibreHardwareMonitor (WMI enabled) usually fixes this.
		                        </div>
		                    </div>
	                </div>

	                <h3>Notes</h3>
	                <div style="background: #e7f3ff; border-left: 3px solid #2196f3; padding: 15px; border-radius: 5px; margin-bottom: 20px;">
"@
	    foreach ($note in $testData.AdapterTest.Notes) {
	        $htmlContent += @"
	                    <div style="margin-bottom: 8px; color: #1565c0; font-size: 13px;"><span style="font-weight: bold;">*</span> $note</div>
"@
	    }
	    $htmlContent += @"
	                </div>

	                <h3>Recommendations</h3>
	                <div style="background: #e8f5e9; border-left: 3px solid #27ae60; padding: 15px; border-radius: 5px;">
"@
	    foreach ($rec in $testData.AdapterTest.Recommendations) {
	        $htmlContent += @"
	                    <div style="margin-bottom: 8px; color: #27ae60;"><span style="font-weight: bold;">[OK]</span> $rec</div>
"@
	    }
	    $htmlContent += @"
	                </div>
"@
	}

$htmlContent += @"
            </div>
        </div>

        <div id="hardware" class="tab-content">
            <h2 style="margin-bottom: 20px;">Detailed Hardware Information</h2>

            <!-- Temperature Section -->
            <div class="test-section" style="margin-bottom: 30px;">
                <h3 style="margin-bottom: 15px;">Temperature & Cooling</h3>
"@

if ($testData.Temperature.CPUTemp -ne "N/A") {
    $tempColor = if ($testData.Temperature.CelsiusValue -lt 65) { '#27ae60' }
                 elseif ($testData.Temperature.CelsiusValue -lt 75) { '#3498db' }
                 elseif ($testData.Temperature.CelsiusValue -lt 85) { '#f39c12' }
                 else { '#e74c3c' }

    $htmlContent += @"
                <div class="cards">
                    <div class="card">
                        <h3>CPU Temperature</h3>
                        <div style="text-align: center; padding: 15px 0;">
                            <div style="font-size: 36px; font-weight: bold; color: $tempColor;">$($testData.Temperature.CPUTemp)</div>
                            <div style="font-size: 14px; color: #7f8c8d; margin-top: 8px;">$($testData.Temperature.Status)</div>
                        </div>
                    </div>
"@

    if ($testData.Temperature.StressTest.Tested) {
        $assessmentColor = switch ($testData.Temperature.StressTest.HeatingAssessment) {
            "Critical Issues" { '#e74c3c' }
            "Moderate Issues" { '#f39c12' }
            "Minor Issues" { '#f39c12' }
            "Good" { '#3498db' }
            "Excellent" { '#27ae60' }
            default { '#95a5a6' }
        }

        $htmlContent += @"
                    <div class="card">
                        <h3>Stress Test (15s)</h3>
                        <div class="card-row">
                            <span class="label">Before</span>
                            <span class="value">$($testData.Temperature.StressTest.Before)°C</span>
                        </div>
                        <div class="card-row">
                            <span class="label">After</span>
                            <span class="value">$($testData.Temperature.StressTest.After)°C</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Delta</span>
                            <span class="value" style="color: #e74c3c; font-weight: bold;">+$($testData.Temperature.StressTest.Delta)°C</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Max Temp</span>
                            <span class="value" style="color: #e74c3c;">$($testData.Temperature.StressTest.Max)°C</span>
                        </div>
                    </div>
                    <div class="card" style="border-left: 3px solid $assessmentColor;">
                        <h3>Assessment</h3>
                        <div style="text-align: center; padding: 15px 0;">
                            <div style="font-size: 24px; font-weight: bold; color: $assessmentColor;">$($testData.Temperature.StressTest.HeatingAssessment)</div>
                        </div>
                    </div>
"@
    }

    $htmlContent += @"
                </div>
"@
} else {
    $htmlContent += @"
                <div class="cards">
                    <div class="card">
                        <h3>CPU Temperature</h3>
                        <div class="card-row"><span class="label">Status</span><span class="value">Sensor Not Found</span></div>
                        <div class="card-row"><span class="label">Source</span><span class="value">$($testData.Temperature.Source)</span></div>
                        <div style="margin-top: 10px; padding: 10px; background: #e7f3ff; border-radius: 6px; border-left: 3px solid #2196f3;">
                            <div style="font-size: 13px; color: #1565c0; line-height: 1.6;">
                                <div><strong>Why:</strong> Windows often cannot read CPU/PSU sensors on desktops without a hardware-monitor sensor provider.</div>
                                <div style="margin-top: 6px;"><strong>Tip:</strong> Run LibreHardwareMonitor or OpenHardwareMonitor (WMI enabled) and re-run the diagnostic.</div>
                            </div>
                        </div>
                    </div>

                    <div class="card">
                        <h3>WMI Service</h3>
                        <div class="card-row"><span class="label">Running</span><span class="value">$([string]$testData.WmiService.Running)</span></div>
                        <div class="card-row"><span class="label">Message</span><span class="value">$($testData.WmiService.Message)</span></div>
                    </div>
                </div>
"@
}

$htmlContent += @"
            </div>

            <div class="cards">
                <div class="card">
                    <h3>CPU Cache</h3>
                    <div class="card-row">
                        <span class="label">L2 Cache</span>
                        <span class="value">$($testData.CPU.L2Cache)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">L3 Cache</span>
                        <span class="value">$($testData.CPU.L3Cache)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Virtualization</span>
                        <span class="value">$($testData.CPU.Virtualization)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Socket</span>
                        <span class="value">$($testData.CPU.Sockets)</span>
                    </div>
                </div>

                <div class="card">
                    <h3>Audio Devices</h3>
"@

foreach ($audio in $testData.Audio.Devices) {
    $htmlContent += @"
                    <div class="card-row">
                        <span class="label">$($audio.Name)</span>
                        <span class="value">$($audio.Status)</span>
                    </div>
"@
}

$htmlContent += @"
                </div>

                <div class="card">
                    <h3>Input Devices</h3>
                    <div class="card-row">
                        <span class="label">Keyboards</span>
                        <span class="value">$($testData.InputDevices.Keyboards)</span>
                    </div>
                    <div class="card-row">
                        <span class="label">Pointing Devices</span>
                        <span class="value">$($testData.InputDevices.PointingDevices)</span>
                    </div>
                </div>

                <div class="card">
                    <h3>Network Adapters</h3>
"@

foreach ($adapter in $testData.Network.Adapters) {
    $htmlContent += @"
                    <div class="card-row">
                        <span class="label">$($adapter.Name)</span>
                        <span class="value">$($adapter.Speed)</span>
                    </div>
"@
}

$htmlContent += @"
                </div>
            </div>
        </div>

        <div id="keyboard" class="tab-content">
            <h2 style="margin-bottom: 20px;">Keyboard Test</h2>

            <div class="test-section">
                <h3>Press any key to test</h3>
                <p style="margin-bottom: 20px; color: #7f8c8d;">Keys will turn green when pressed. Test all keys to ensure they work correctly.</p>

                <div id="keyboard-display" class="keyboard-grid">
                    <!-- Keys will be dynamically added here -->
                </div>

                <button class="test-button" onclick="resetKeyboard()">Reset Test</button>
            </div>
        </div>

        <div id="touchpad" class="tab-content">
            <h2 style="margin-bottom: 20px;">Touchpad/Mouse Test</h2>

            <div class="test-section">
                <h3>Draw on the canvas to test</h3>
                <p style="margin-bottom: 20px; color: #7f8c8d;">Click, drag, and test all mouse buttons and touchpad gestures.</p>

                <div class="status-grid">
                    <div class="status-item">
                        <div class="label">Left Click</div>
                        <div class="value" id="leftClickStatus" style="color: #e74c3c;">Not Tested</div>
                    </div>
                    <div class="status-item">
                        <div class="label">Right Click</div>
                        <div class="value" id="rightClickStatus" style="color: #e74c3c;">Not Tested</div>
                    </div>
                    <div class="status-item">
                        <div class="label">Movement</div>
                        <div class="value" id="moveStatus" style="color: #e74c3c;">Not Tested</div>
                    </div>
                    <div class="status-item">
                        <div class="label">Drag</div>
                        <div class="value" id="dragStatus" style="color: #e74c3c;">Not Tested</div>
                    </div>
                </div>

                <canvas id="touchpad-canvas" class="touchpad-test" width="800" height="400"></canvas>

                <div style="margin-top: 20px;">
                    <button class="test-button" onclick="clearCanvas()">Clear Canvas</button>
                    <button class="test-button" onclick="changeDrawColor('#000000')">Black</button>
                    <button class="test-button" onclick="changeDrawColor('#e74c3c')">Red</button>
                    <button class="test-button" onclick="changeDrawColor('#3498db')">Blue</button>
                    <button class="test-button" onclick="changeDrawColor('#27ae60')">Green</button>
                </div>
            </div>
        </div>

        <div id="display" class="tab-content">
            <h2 style="margin-bottom: 20px;">Display Test</h2>

            <div class="test-section">
                <h3>Screen Properties</h3>
                <div class="cards">
                    <div class="card">
                        <div class="card-row">
                            <span class="label">Resolution</span>
                            <span class="value">$($testData.Display.Resolution)</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Screen Size</span>
                            <span class="value" style="color: #27ae60; font-weight: bold;">$($testData.Display.ScreenSize)</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Refresh Rate</span>
                            <span class="value">$($testData.Display.RefreshRate) Hz</span>
                        </div>
                        <div class="card-row">
                            <span class="label">Touchscreen</span>
                            <span class="value">$(if ($testData.Display.Touchscreen) { 'Yes' } else { 'No' })</span>
                        </div>
                    </div>
                </div>
            </div>

            <div class="test-section">
                <h3>Dead Pixel Test</h3>
                <p style="margin-bottom: 20px; color: #7f8c8d;">Click a color to test fullscreen. Look carefully for dead or stuck pixels. Press ESC or click to exit.</p>

                <button class="test-button" onclick="testColorFullscreen('black')" style="background: #000;">Test Black</button>
                <button class="test-button" onclick="testColorFullscreen('white')" style="background: #fff; color: #000;">Test White</button>
                <button class="test-button" onclick="testColorFullscreen('red')" style="background: #f00;">Test Red</button>
                <button class="test-button" onclick="testColorFullscreen('green')" style="background: #0f0;">Test Green</button>
                <button class="test-button" onclick="testColorFullscreen('blue')" style="background: #00f;">Test Blue</button>
                <button class="test-button" onclick="testColorFullscreen('yellow')" style="background: #ff0;">Test Yellow</button>
            </div>
        </div>

        <div id="audio" class="tab-content">
            <h2 style="margin-bottom: 20px;">Audio Test</h2>

            <div class="test-section">
                <h3>Speaker Test</h3>
                <p style="margin-bottom: 20px; color: #7f8c8d;">Test your laptop speakers. You should hear a 440Hz tone from the selected speaker.</p>

                <div class="cards">
                    <div class="card">
                        <h3>Stereo Test</h3>
                        <button class="test-button" onclick="playLeftSpeaker()">Test Left Speaker</button>
                        <button class="test-button" onclick="playRightSpeaker()">Test Right Speaker</button>
                        <button class="test-button" onclick="playBothSpeakers()">Test Both Speakers</button>
                    </div>

                    <div class="card">
                        <h3>Frequency Test</h3>
                        <button class="test-button" onclick="playSweep()">Play Frequency Sweep</button>
                        <p style="margin-top: 10px; font-size: 13px; color: #7f8c8d;">Plays a 200Hz-2000Hz sweep. You should hear the pitch increase smoothly.</p>
                    </div>
                </div>

                <div class="card" style="margin-top: 20px;">
                    <h3>Detected Audio Devices</h3>
"@

foreach ($audio in $testData.Audio.Devices) {
    $htmlContent += @"
                    <div class="card-row">
                        <span class="label">$($audio.Name)</span>
                        <span class="value">$($audio.Status)</span>
                    </div>
"@
}

$htmlContent += @"
                </div>
            </div>
        </div>

        <div id="microphone" class="tab-content">
            <h2 style="margin-bottom: 20px;">Microphone Test</h2>

            <div class="test-section">
                <h3>Test Your Microphone</h3>
                <p style="margin-bottom: 20px; color: #7f8c8d;">Click "Start Test" and speak into your microphone. The level meter will show audio input.</p>

                <div class="cards">
                    <div class="card">
                        <h3>Microphone Selection</h3>
                        <select id="micSelect" class="mic-select" onchange="switchMicrophone()">
                            <option value="">Select a microphone...</option>
                        </select>
                        <div style="margin-top: 15px;">
                            <button class="test-button" id="micStartBtn" onclick="startMicTest()">Start Test</button>
                            <button class="test-button" id="micStopBtn" onclick="stopMicTest()" style="display:none; background:#e74c3c;">Stop Test</button>
                        </div>
                    </div>

                    <div class="card">
                        <h3>Audio Level</h3>
                        <div class="mic-level-container">
                            <div class="mic-level-bar" id="micLevelBar"></div>
                        </div>
                        <div style="margin-top: 10px; text-align: center;">
                            <span id="micLevelText" style="font-size: 24px; font-weight: bold; color: #7f8c8d;">0%</span>
                        </div>
                        <div id="micStatus" style="margin-top: 15px; text-align: center; padding: 10px; border-radius: 8px; background: #f0f0f0;">
                            <span style="color: #7f8c8d;">Not tested</span>
                        </div>
                    </div>
                </div>

                <div class="card" style="margin-top: 20px;">
                    <h3>Detected Microphones</h3>
                    <div id="micDeviceList">
                        <p style="color: #7f8c8d;">Click "Start Test" to detect microphones...</p>
                    </div>
                </div>
            </div>
        </div>

        <div id="webcam" class="tab-content">
            <h2 style="margin-bottom: 20px;">Webcam Test</h2>

            <div class="test-section">
                <h3>Test Your Webcam</h3>
                <p style="margin-bottom: 20px; color: #7f8c8d;">Click "Start Camera" to preview your webcam. You can switch cameras and take photos.</p>

                <div class="cards">
                    <div class="card">
                        <h3>Camera Selection</h3>
                        <select id="camSelect" class="mic-select" onchange="switchCamera()">
                            <option value="">Select a camera...</option>
                        </select>
                        <div style="margin-top: 15px;">
                            <button class="test-button" id="camStartBtn" onclick="startCamTest()">Start Camera</button>
                            <button class="test-button" id="camStopBtn" onclick="stopCamTest()" style="display:none; background:#e74c3c;">Stop Camera</button>
                            <button class="test-button" id="camPhotoBtn" onclick="takePhoto()" style="display:none; background:#27ae60;">Take Photo</button>
                        </div>
                    </div>

                    <div class="card">
                        <h3>Camera Info</h3>
                        <div id="camInfo">
                            <div class="card-row">
                                <span class="label">Status</span>
                                <span class="value" id="camStatus" style="color: #7f8c8d;">Not started</span>
                            </div>
                            <div class="card-row">
                                <span class="label">Resolution</span>
                                <span class="value" id="camResolution">-</span>
                            </div>
                        </div>
                    </div>
                </div>

                <div class="card" style="margin-top: 20px;">
                    <h3>Camera Preview</h3>
                    <div style="display: flex; gap: 20px; flex-wrap: wrap;">
                        <div style="flex: 1; min-width: 300px;">
                            <video id="camPreview" autoplay playsinline style="width: 100%; max-height: 400px; background: #000; border-radius: 8px; display: none;"></video>
                            <div id="camPlaceholder" style="width: 100%; height: 300px; background: #1a1a1a; border-radius: 8px; display: flex; align-items: center; justify-content: center; color: #666;">
                                Camera preview will appear here
                            </div>
                        </div>
                        <div style="flex: 1; min-width: 300px;">
                            <h4 style="margin-bottom: 10px; color: #7f8c8d;">Captured Photo</h4>
                            <canvas id="camCanvas" style="width: 100%; max-height: 400px; background: #1a1a1a; border-radius: 8px;"></canvas>
                        </div>
                    </div>
                </div>

                <div class="card" style="margin-top: 20px;">
                    <h3>Detected Cameras</h3>
                    <div id="camDeviceList">
                        <p style="color: #7f8c8d;">Click "Start Camera" to detect webcams...</p>
                    </div>
                </div>
            </div>
        </div>

        <!-- Footer -->
        <div class="report-footer">
            <div class="footer-content">
                <div class="footer-brand">
                    <span class="footer-logo-icon"></span>
                    <span class="footer-title">Hardware Diagnostic Tool</span>
                </div>
	                <div class="footer-info">
	                    <p>Generated on $timestampDisplay</p>
                    <p class="powered-by">Powered By <strong>Hybrid Systems</strong></p>
                </div>
                <div class="footer-links">
	                    <a href="https://hybridsystems.in" target="_blank">Visit Website</a>
                </div>
            </div>
        </div>
    </div>

    <script>
        let drawColor = '#000000';

        // Tab Management - Fixed
        function openTab(tabName, evt) {
            try {
                // Hide all tab contents
                const tabContents = document.querySelectorAll('.tab-content');
                tabContents.forEach(content => {
                    content.classList.remove('active');
                });

                // Remove active class from all buttons
                const tabButtons = document.querySelectorAll('.tab-button');
                tabButtons.forEach(button => {
                    button.classList.remove('active');
                });

                // Show the selected tab content
                const selectedTab = document.getElementById(tabName);
                if (selectedTab) {
                    selectedTab.classList.add('active');
                }

                // Activate the clicked button
                if (evt && evt.currentTarget) {
                    evt.currentTarget.classList.add('active');
                }

                // Initialize interactive tests when tab opens
                if (tabName === 'keyboard') {
                    setTimeout(initKeyboard, 100);
                } else if (tabName === 'touchpad') {
                    setTimeout(initCanvas, 100);
                }
            } catch (error) {
                console.error('Error opening tab:', error);
            }
        }

        // Keyboard Test Functions
        const keyboardRows = [
            { label: 'Function Keys', keys: ['Escape', 'F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'F10', 'F11', 'F12', 'PrintScreen', 'ScrollLock', 'Pause'] },
            { label: 'Number Row', keys: ['Backquote', 'Digit1', 'Digit2', 'Digit3', 'Digit4', 'Digit5', 'Digit6', 'Digit7', 'Digit8', 'Digit9', 'Digit0', 'Minus', 'Equal', 'Backspace'] },
            { label: 'Top Row', keys: ['Tab', 'KeyQ', 'KeyW', 'KeyE', 'KeyR', 'KeyT', 'KeyY', 'KeyU', 'KeyI', 'KeyO', 'KeyP', 'BracketLeft', 'BracketRight', 'Backslash'] },
            { label: 'Home Row', keys: ['CapsLock', 'KeyA', 'KeyS', 'KeyD', 'KeyF', 'KeyG', 'KeyH', 'KeyJ', 'KeyK', 'KeyL', 'Semicolon', 'Quote', 'Enter'] },
            { label: 'Bottom Row', keys: ['ShiftLeft', 'KeyZ', 'KeyX', 'KeyC', 'KeyV', 'KeyB', 'KeyN', 'KeyM', 'Comma', 'Period', 'Slash', 'ShiftRight'] },
            { label: 'Space Row', keys: ['ControlLeft', 'MetaLeft', 'AltLeft', 'Space', 'AltRight', 'MetaRight', 'ContextMenu', 'ControlRight'] },
            { label: 'Navigation', keys: ['Insert', 'Home', 'PageUp', 'Delete', 'End', 'PageDown'] },
            { label: 'Arrows', keys: ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'] },
            { label: 'Numpad', keys: ['NumLock', 'NumpadDivide', 'NumpadMultiply', 'NumpadSubtract', 'Numpad7', 'Numpad8', 'Numpad9', 'NumpadAdd', 'Numpad4', 'Numpad5', 'Numpad6', 'Numpad1', 'Numpad2', 'Numpad3', 'NumpadEnter', 'Numpad0', 'NumpadDecimal'] }
        ];

        let keydownListener = null;

        function initKeyboard() {
            const display = document.getElementById('keyboard-display');
            if (!display) return;

            // Clear existing content
            display.innerHTML = '';

            // Create keyboard layout by rows
            keyboardRows.forEach(row => {
                const rowDiv = document.createElement('div');
                rowDiv.className = 'keyboard-row';
                rowDiv.innerHTML = '<div class="row-label">' + row.label + '</div>';

                const keysContainer = document.createElement('div');
                keysContainer.className = 'keys-container';

                row.keys.forEach(key => {
                    const keyDiv = document.createElement('div');
                    keyDiv.className = 'key';
                    keyDiv.id = 'key-' + key;

                    // Display friendly names
                    const keyNames = {
                        'Space': 'Space', 'Backspace': 'Back', 'Enter': 'Enter', 'Tab': 'Tab',
                        'ShiftLeft': 'Shift L', 'ShiftRight': 'Shift R',
                        'ControlLeft': 'Ctrl L', 'ControlRight': 'Ctrl R',
                        'AltLeft': 'Alt L', 'AltRight': 'Alt R',
                        'MetaLeft': 'Win L', 'MetaRight': 'Win R',
                        'Backquote': '`', 'Minus': '-', 'Equal': '=',
                        'BracketLeft': '[', 'BracketRight': ']', 'Backslash': '\\',
                        'Semicolon': ';', 'Quote': "'", 'Comma': ',', 'Period': '.', 'Slash': '/',
                        'CapsLock': 'Caps', 'Escape': 'Esc',
                        'PrintScreen': 'PrtSc', 'ScrollLock': 'ScrLk', 'Pause': 'Pause',
                        'Insert': 'Ins', 'Delete': 'Del', 'Home': 'Home', 'End': 'End',
                        'PageUp': 'PgUp', 'PageDown': 'PgDn',
                        'ArrowUp': 'Up', 'ArrowDown': 'Down', 'ArrowLeft': 'Left', 'ArrowRight': 'Right',
                        'ContextMenu': 'Menu',
                        'NumLock': 'Num', 'NumpadDivide': '/', 'NumpadMultiply': '*',
                        'NumpadSubtract': '-', 'NumpadAdd': '+', 'NumpadEnter': 'Enter',
                        'NumpadDecimal': '.', 'Numpad0': '0', 'Numpad1': '1', 'Numpad2': '2',
                        'Numpad3': '3', 'Numpad4': '4', 'Numpad5': '5', 'Numpad6': '6',
                        'Numpad7': '7', 'Numpad8': '8', 'Numpad9': '9'
                    };
                    let displayText = keyNames[key] || key.replace('Key', '').replace('Digit', '');

                    keyDiv.textContent = displayText;
                    if (key === 'Space') keyDiv.style.minWidth = '200px';
                    if (key === 'Backspace' || key === 'Tab' || key === 'CapsLock' || key === 'Enter' || key === 'ShiftLeft' || key === 'ShiftRight') keyDiv.style.minWidth = '60px';
                    if (key.startsWith('Numpad')) keyDiv.classList.add('numpad-key');

                    keysContainer.appendChild(keyDiv);
                });

                rowDiv.appendChild(keysContainer);
                display.appendChild(rowDiv);
            });

            // Remove old listener if exists
            if (keydownListener) {
                document.removeEventListener('keydown', keydownListener);
            }

            // Add new listener with preventDefault
            keydownListener = handleKeyPress;
            document.addEventListener('keydown', keydownListener);
        }

        function handleKeyPress(e) {
            // Prevent default browser behavior for all keys during test
            if (document.getElementById('keyboard').classList.contains('active')) {
                e.preventDefault();

                const keyElement = document.getElementById('key-' + e.code);
                if (keyElement) {
                    keyElement.classList.add('pressed');
                }
            }
        }

        function resetKeyboard() {
            document.querySelectorAll('.key').forEach(key => {
                key.classList.remove('pressed');
            });
        }

        // Touchpad Test Functions
        function initCanvas() {
            const canvas = document.getElementById('touchpad-canvas');
            if (!canvas) return;

            const ctx = canvas.getContext('2d');
            ctx.strokeStyle = drawColor;
            ctx.lineWidth = 3;
            ctx.lineCap = 'round';

            let isDrawing = false;
            let lastX = 0, lastY = 0;

            function draw(e) {
                if (!isDrawing) return;

                const rect = canvas.getBoundingClientRect();
                const x = e.clientX - rect.left;
                const y = e.clientY - rect.top;

                ctx.beginPath();
                ctx.moveTo(lastX, lastY);
                ctx.lineTo(x, y);
                ctx.stroke();

                lastX = x;
                lastY = y;

                updateStatus('moveStatus', 'Working', true);
                updateStatus('dragStatus', 'Working', true);
            }

            canvas.addEventListener('mousedown', (e) => {
                isDrawing = true;
                const rect = canvas.getBoundingClientRect();
                lastX = e.clientX - rect.left;
                lastY = e.clientY - rect.top;

                if (e.button === 0) updateStatus('leftClickStatus', 'Working', true);
                if (e.button === 2) updateStatus('rightClickStatus', 'Working', true);
            });

            canvas.addEventListener('mousemove', draw);
            canvas.addEventListener('mouseup', () => isDrawing = false);
            canvas.addEventListener('mouseleave', () => isDrawing = false);

            canvas.addEventListener('touchstart', (e) => {
                e.preventDefault();
                isDrawing = true;
                const rect = canvas.getBoundingClientRect();
                const touch = e.touches[0];
                lastX = touch.clientX - rect.left;
                lastY = touch.clientY - rect.top;
                updateStatus('leftClickStatus', 'Working', true);
            });

            canvas.addEventListener('touchmove', (e) => {
                e.preventDefault();
                if (!isDrawing) return;

                const rect = canvas.getBoundingClientRect();
                const touch = e.touches[0];
                const x = touch.clientX - rect.left;
                const y = touch.clientY - rect.top;

                ctx.beginPath();
                ctx.moveTo(lastX, lastY);
                ctx.lineTo(x, y);
                ctx.stroke();

                lastX = x;
                lastY = y;

                updateStatus('moveStatus', 'Working', true);
                updateStatus('dragStatus', 'Working', true);
            });

            canvas.addEventListener('touchend', () => isDrawing = false);

            canvas.addEventListener('contextmenu', (e) => {
                e.preventDefault();
                updateStatus('rightClickStatus', 'Working', true);
            });
        }

        function updateStatus(id, status, working) {
            const element = document.getElementById(id);
            if (element) {
                element.textContent = status;
                element.style.color = working ? '#27ae60' : '#e74c3c';
            }
        }

        function clearCanvas() {
            const canvas = document.getElementById('touchpad-canvas');
            const ctx = canvas.getContext('2d');
            ctx.clearRect(0, 0, canvas.width, canvas.height);
        }

        function changeDrawColor(color) {
            drawColor = color;
            const canvas = document.getElementById('touchpad-canvas');
            const ctx = canvas.getContext('2d');
            ctx.strokeStyle = color;
        }

        // Display Test Functions
        function testColorFullscreen(color) {
            const overlay = document.createElement('div');
            overlay.style.cssText = 'position: fixed; top: 0; left: 0; width: 100%; height: 100%; background: '+color+'; z-index: 99999; cursor: none;';
            overlay.id = 'fullscreen-color-test';

            const instruction = document.createElement('div');
            instruction.style.cssText = 'position: absolute; top: '+(Math.random() * 80 + 10)+'%; left: '+(Math.random() * 80 + 10)+'%; color: '+(color === 'white' || color === 'yellow' ? 'black' : 'white')+'; font-size: 24px; font-weight: bold; text-shadow: 0 0 10px '+(color === 'white' ? 'black' : 'white')+';';
            instruction.textContent = 'Testing ' + color.toUpperCase() + ' - Look for dead pixels. Press ESC or click to exit.';

            overlay.appendChild(instruction);
            document.body.appendChild(overlay);

            // Request fullscreen mode (hides browser UI)
            const elem = overlay;
            if (elem.requestFullscreen) {
                elem.requestFullscreen().catch(err => {
                    console.log('Fullscreen request failed:', err);
                });
            } else if (elem.webkitRequestFullscreen) {
                elem.webkitRequestFullscreen();
            } else if (elem.msRequestFullscreen) {
                elem.msRequestFullscreen();
            } else if (elem.mozRequestFullScreen) {
                elem.mozRequestFullScreen();
            }

            function exitTest() {
                // Exit fullscreen mode
                if (document.exitFullscreen) {
                    document.exitFullscreen().catch(() => {});
                } else if (document.webkitExitFullscreen) {
                    document.webkitExitFullscreen();
                } else if (document.msExitFullscreen) {
                    document.msExitFullscreen();
                } else if (document.mozCancelFullScreen) {
                    document.mozCancelFullScreen();
                }

                // Remove overlay
                setTimeout(() => {
                    if (overlay.parentNode) {
                        document.body.removeChild(overlay);
                    }
                    document.removeEventListener('keydown', handleEscape);
                    overlay.removeEventListener('click', exitTest);
                    document.removeEventListener('fullscreenchange', handleFullscreenChange);
                    document.removeEventListener('webkitfullscreenchange', handleFullscreenChange);
                    document.removeEventListener('msfullscreenchange', handleFullscreenChange);
                    document.removeEventListener('mozfullscreenchange', handleFullscreenChange);
                }, 100);
            }

            function handleEscape(e) {
                if (e.key === 'Escape') exitTest();
            }

            function handleFullscreenChange() {
                // Exit test when user exits fullscreen mode
                if (!document.fullscreenElement && !document.webkitFullscreenElement &&
                    !document.msFullscreenElement && !document.mozFullScreenElement) {
                    exitTest();
                }
            }

            document.addEventListener('keydown', handleEscape);
            overlay.addEventListener('click', exitTest);
            document.addEventListener('fullscreenchange', handleFullscreenChange);
            document.addEventListener('webkitfullscreenchange', handleFullscreenChange);
            document.addEventListener('msfullscreenchange', handleFullscreenChange);
            document.addEventListener('mozfullscreenchange', handleFullscreenChange);
        }

        // Audio Test Functions
        let audioContext = null;

        function getAudioContext() {
            if (!audioContext) {
                audioContext = new (window.AudioContext || window.webkitAudioContext)();
            }
            return audioContext;
        }

        function playLeftSpeaker() {
            const ctx = getAudioContext();
            const oscillator = ctx.createOscillator();
            const gainNode = ctx.createGain();
            const panner = ctx.createStereoPanner();

            oscillator.connect(gainNode);
            gainNode.connect(panner);
            panner.connect(ctx.destination);

            panner.pan.value = -1; // Left speaker
            oscillator.frequency.value = 440;
            oscillator.type = 'sine';

            oscillator.start();
            setTimeout(() => oscillator.stop(), 1000);
        }

        function playRightSpeaker() {
            const ctx = getAudioContext();
            const oscillator = ctx.createOscillator();
            const gainNode = ctx.createGain();
            const panner = ctx.createStereoPanner();

            oscillator.connect(gainNode);
            gainNode.connect(panner);
            panner.connect(ctx.destination);

            panner.pan.value = 1; // Right speaker
            oscillator.frequency.value = 440;
            oscillator.type = 'sine';

            oscillator.start();
            setTimeout(() => oscillator.stop(), 1000);
        }

        function playBothSpeakers() {
            const ctx = getAudioContext();
            const oscillator = ctx.createOscillator();
            const gainNode = ctx.createGain();

            oscillator.connect(gainNode);
            gainNode.connect(ctx.destination);

            oscillator.frequency.value = 440;
            oscillator.type = 'sine';

            oscillator.start();
            setTimeout(() => oscillator.stop(), 1000);
        }

        function playSweep() {
            const ctx = getAudioContext();
            const oscillator = ctx.createOscillator();
            const gainNode = ctx.createGain();

            oscillator.connect(gainNode);
            gainNode.connect(ctx.destination);

            oscillator.frequency.setValueAtTime(200, ctx.currentTime);
            oscillator.frequency.exponentialRampToValueAtTime(2000, ctx.currentTime + 2);
            oscillator.type = 'sine';

            oscillator.start();
            setTimeout(() => oscillator.stop(), 2000);
        }

        // Microphone Test Functions
        let micStream = null;
        let micAnalyser = null;
        let micAnimationId = null;

        async function startMicTest() {
            try {
                micStream = await navigator.mediaDevices.getUserMedia({ audio: true });
                const ctx = getAudioContext();
                const source = ctx.createMediaStreamSource(micStream);
                micAnalyser = ctx.createAnalyser();
                micAnalyser.fftSize = 256;
                source.connect(micAnalyser);

                document.getElementById('micStartBtn').style.display = 'none';
                document.getElementById('micStopBtn').style.display = 'inline-block';
                document.getElementById('micStatus').innerHTML = '<span style="color: #27ae60;">Listening...</span>';

                updateMicLevel();
                await updateMicDeviceList();
            } catch (err) {
                document.getElementById('micStatus').innerHTML = '<span style="color: #e74c3c;">Error: ' + err.message + '</span>';
            }
        }

        function updateMicLevel() {
            if (!micAnalyser) return;
            const dataArray = new Uint8Array(micAnalyser.frequencyBinCount);
            micAnalyser.getByteFrequencyData(dataArray);
            const average = dataArray.reduce((a, b) => a + b) / dataArray.length;
            const level = Math.min(100, Math.round((average / 128) * 100));
            document.getElementById('micLevelBar').style.width = level + '%';
            document.getElementById('micLevelText').textContent = level + '%';
            document.getElementById('micLevelText').style.color = level > 10 ? '#27ae60' : '#7f8c8d';
            if (level > 10) {
                document.getElementById('micStatus').innerHTML = '<span style="color: #27ae60;">Working - Audio detected!</span>';
            }
            micAnimationId = requestAnimationFrame(updateMicLevel);
        }

        function stopMicTest() {
            if (micStream) {
                micStream.getTracks().forEach(track => track.stop());
                micStream = null;
            }
            if (micAnimationId) {
                cancelAnimationFrame(micAnimationId);
                micAnimationId = null;
            }
            document.getElementById('micStartBtn').style.display = 'inline-block';
            document.getElementById('micStopBtn').style.display = 'none';
            document.getElementById('micLevelBar').style.width = '0%';
            document.getElementById('micLevelText').textContent = '0%';
            document.getElementById('micStatus').innerHTML = '<span style="color: #7f8c8d;">Test stopped</span>';
        }

        async function updateMicDeviceList() {
            const devices = await navigator.mediaDevices.enumerateDevices();
            const mics = devices.filter(d => d.kind === 'audioinput');
            const select = document.getElementById('micSelect');
            const list = document.getElementById('micDeviceList');
            select.innerHTML = '<option value="">Select a microphone...</option>';
            list.innerHTML = '';
            mics.forEach((mic, i) => {
                const name = mic.label || 'Microphone ' + (i + 1);
                select.innerHTML += '<option value="' + mic.deviceId + '">' + name + '</option>';
                list.innerHTML += '<div class="card-row"><span class="label">' + name + '</span><span class="value" style="color:#27ae60;">Detected</span></div>';
            });
        }

        async function switchMicrophone() {
            const deviceId = document.getElementById('micSelect').value;
            if (!deviceId) return;
            stopMicTest();
            try {
                micStream = await navigator.mediaDevices.getUserMedia({ audio: { deviceId: { exact: deviceId } } });
                const ctx = getAudioContext();
                const source = ctx.createMediaStreamSource(micStream);
                micAnalyser = ctx.createAnalyser();
                micAnalyser.fftSize = 256;
                source.connect(micAnalyser);
                document.getElementById('micStartBtn').style.display = 'none';
                document.getElementById('micStopBtn').style.display = 'inline-block';
                document.getElementById('micStatus').innerHTML = '<span style="color: #27ae60;">Listening...</span>';
                updateMicLevel();
            } catch (err) {
                document.getElementById('micStatus').innerHTML = '<span style="color: #e74c3c;">Error: ' + err.message + '</span>';
            }
        }

        // Webcam Test Functions
        let camStream = null;

        async function startCamTest() {
            try {
                camStream = await navigator.mediaDevices.getUserMedia({ video: true });
                const video = document.getElementById('camPreview');
                video.srcObject = camStream;
                video.style.display = 'block';
                document.getElementById('camPlaceholder').style.display = 'none';
                document.getElementById('camStartBtn').style.display = 'none';
                document.getElementById('camStopBtn').style.display = 'inline-block';
                document.getElementById('camPhotoBtn').style.display = 'inline-block';
                document.getElementById('camStatus').textContent = 'Active';
                document.getElementById('camStatus').style.color = '#27ae60';
                video.onloadedmetadata = () => {
                    document.getElementById('camResolution').textContent = video.videoWidth + ' x ' + video.videoHeight;
                };
                await updateCamDeviceList();
            } catch (err) {
                document.getElementById('camStatus').textContent = 'Error: ' + err.message;
                document.getElementById('camStatus').style.color = '#e74c3c';
            }
        }

        function stopCamTest() {
            if (camStream) {
                camStream.getTracks().forEach(track => track.stop());
                camStream = null;
            }
            document.getElementById('camPreview').style.display = 'none';
            document.getElementById('camPlaceholder').style.display = 'flex';
            document.getElementById('camStartBtn').style.display = 'inline-block';
            document.getElementById('camStopBtn').style.display = 'none';
            document.getElementById('camPhotoBtn').style.display = 'none';
            document.getElementById('camStatus').textContent = 'Stopped';
            document.getElementById('camStatus').style.color = '#7f8c8d';
            document.getElementById('camResolution').textContent = '-';
        }

        function takePhoto() {
            const video = document.getElementById('camPreview');
            const canvas = document.getElementById('camCanvas');
            canvas.width = video.videoWidth;
            canvas.height = video.videoHeight;
            const ctx = canvas.getContext('2d');
            ctx.drawImage(video, 0, 0);
        }

        async function updateCamDeviceList() {
            const devices = await navigator.mediaDevices.enumerateDevices();
            const cams = devices.filter(d => d.kind === 'videoinput');
            const select = document.getElementById('camSelect');
            const list = document.getElementById('camDeviceList');
            select.innerHTML = '<option value="">Select a camera...</option>';
            list.innerHTML = '';
            cams.forEach((cam, i) => {
                const name = cam.label || 'Camera ' + (i + 1);
                select.innerHTML += '<option value="' + cam.deviceId + '">' + name + '</option>';
                list.innerHTML += '<div class="card-row"><span class="label">' + name + '</span><span class="value" style="color:#27ae60;">Detected</span></div>';
            });
        }

        async function switchCamera() {
            const deviceId = document.getElementById('camSelect').value;
            if (!deviceId) return;
            stopCamTest();
            try {
                camStream = await navigator.mediaDevices.getUserMedia({ video: { deviceId: { exact: deviceId } } });
                const video = document.getElementById('camPreview');
                video.srcObject = camStream;
                video.style.display = 'block';
                document.getElementById('camPlaceholder').style.display = 'none';
                document.getElementById('camStartBtn').style.display = 'none';
                document.getElementById('camStopBtn').style.display = 'inline-block';
                document.getElementById('camPhotoBtn').style.display = 'inline-block';
                document.getElementById('camStatus').textContent = 'Active';
                document.getElementById('camStatus').style.color = '#27ae60';
                video.onloadedmetadata = () => {
                    document.getElementById('camResolution').textContent = video.videoWidth + ' x ' + video.videoHeight;
                };
            } catch (err) {
                document.getElementById('camStatus').textContent = 'Error: ' + err.message;
                document.getElementById('camStatus').style.color = '#e74c3c';
            }
        }

        // Initialize on page load
        document.addEventListener('DOMContentLoaded', () => {
            console.log('Laptop Diagnostic Report v15.0 loaded');
        });
    </script>
</body>
</html>
"@

$htmlContent | Out-File -FilePath $reportPath -Encoding UTF8

# Always save a copy to Desktop for easy access
$desktopPath = [Environment]::GetFolderPath("Desktop")
$desktopReportsDir = Join-Path $desktopPath "DiagnosticReports"
New-Item -ItemType Directory -Path $desktopReportsDir -Force | Out-Null
$reportFileName = Split-Path -Leaf $reportPath
$desktopReportPath = Join-Path $desktopReportsDir $reportFileName

# Copy to Desktop if not already there
if ($reportPath -ne $desktopReportPath) {
    Copy-Item -Path $reportPath -Destination $desktopReportPath -Force
}

# Show completion message
Show-Complete

# Open the report automatically
try {
    Start-Process $desktopReportPath
} catch {
    # Silent fail - user can open manually
}

# Brief pause before exit
Start-Sleep -Seconds 2