#Requires -Version 5.1
<#
.SYNOPSIS
    EF-Map Overlay - Injection Failure & Game Freeze Diagnostic Tool

.DESCRIPTION
    Collects comprehensive diagnostics when the overlay fails to start, fails to
    render, or freezes the game client on "Start Overlay". Designed for
    low-friction user execution (download from ef-map.com or Discord).
    Outputs a structured report for developer analysis.

.PARAMETER OutputFile
    Path to save diagnostic report (default: desktop)

.PARAMETER IncludeLogs
    Include full helper log file contents if any exist (increases report size)

.EXAMPLE
    irm https://ef-map.com/ef-helper/diagnose_injection_failure.ps1 | iex
    # Recommended: paste into any PowerShell window - no download, no
    # execution-policy or Mark-of-the-Web problems

.EXAMPLE
    powershell -ExecutionPolicy Bypass -File .\diagnose_injection_failure.ps1
    # Run a downloaded copy without changing your system execution policy

.NOTES
    Version: 1.2.2
    Last Updated: 2026-07-19
    Requires: Windows 10+, PowerShell 5.1+
    Best run while helper and game are both running. If the game FREEZES when
    you press "Start Overlay", run this AFTER the freeze (leave the frozen game
    open if you can) so process/module state can be captured.
    Send the report to support@ef-map.com or the EF-Map Discord.
    DebugView freeze logs are email-only (they can contain login tokens).
    Must stay `irm | iex`-compatible: no [CmdletBinding()], param() first.
#>

param(
    [string]$OutputFile = "",
    [switch]$IncludeLogs
)

# Resolve save location at runtime. [Environment]::GetFolderPath handles
# OneDrive Known Folder Move ($env:USERPROFILE\Desktop is WRONG on those
# machines). Fall back to TEMP if Desktop is unavailable.
if (-not $OutputFile) {
    $desktopDir = [Environment]::GetFolderPath('Desktop')
    if (-not $desktopDir -or -not (Test-Path $desktopDir)) { $desktopDir = $env:TEMP }
    $OutputFile = Join-Path $desktopDir "ef-overlay-diagnostics-$(Get-Date -Format 'yyyyMMdd-HHmmss').txt"
}

# Banner
Write-Host @"
========================================
  EF-Map Overlay Diagnostic Tool v1.2.2
========================================
Collecting system information...

"@ -ForegroundColor Cyan

$script:Report = @()
$script:Issues = @()

# Helper function to add section to report
function Add-Section {
    param([string]$Title, [string]$Content)
    $script:Report += "`n========================================`n"
    $script:Report += "  $Title`n"
    $script:Report += "========================================`n"
    $script:Report += $Content
}

# Helper function to add issue
function Add-Issue {
    param([string]$Severity, [string]$Message)
    $script:Issues += "[${Severity}] $Message"
}

# Per-process token elevation query (works cross-elevation for same-user processes).
# NOTE: v1.0.0 compared the SCRIPT's own admin status for both processes, so the
# elevation-mismatch check could never fire. This queries each target process token.
Add-Type -TypeDefinition @"
using System;
using System.Runtime.InteropServices;
public static class EfElevCheck {
    [DllImport("kernel32.dll", SetLastError=true)]
    static extern IntPtr OpenProcess(uint access, bool inherit, int pid);
    [DllImport("advapi32.dll", SetLastError=true)]
    static extern bool OpenProcessToken(IntPtr proc, uint access, out IntPtr token);
    [DllImport("advapi32.dll", SetLastError=true)]
    static extern bool GetTokenInformation(IntPtr token, int infoClass, out int info, int len, out int retLen);
    [DllImport("kernel32.dll")]
    static extern bool CloseHandle(IntPtr h);
    // Returns 1 = elevated, 0 = not elevated, -1 = unknown (access denied etc.)
    public static int IsElevated(int pid) {
        IntPtr proc = OpenProcess(0x1000, false, pid); // PROCESS_QUERY_LIMITED_INFORMATION
        if (proc == IntPtr.Zero) return -1;
        IntPtr token;
        if (!OpenProcessToken(proc, 0x0008, out token)) { CloseHandle(proc); return -1; } // TOKEN_QUERY
        int elev; int retLen;
        bool ok = GetTokenInformation(token, 20, out elev, 4, out retLen); // TokenElevation
        CloseHandle(token); CloseHandle(proc);
        return ok ? (elev != 0 ? 1 : 0) : -1;
    }
}
"@ -ErrorAction SilentlyContinue

function Get-ProcessElevation {
    param([int]$ProcId)
    try {
        switch ([EfElevCheck]::IsElevated($ProcId)) {
            1 { return "Elevated" }
            0 { return "Not elevated" }
            default { return "Unknown" }
        }
    } catch { return "Unknown" }
}

# ============================================
# 1. SYSTEM INFORMATION
# ============================================
Write-Host "Collecting system information..." -ForegroundColor Yellow

try {
    $os = Get-CimInstance Win32_OperatingSystem
    $sysInfo = @"
OS Name:        $($os.Caption)
OS Version:     $($os.Version)
OS Build:       $($os.BuildNumber)
Architecture:   $([System.Environment]::Is64BitOperatingSystem)
System Type:    $($os.OSArchitecture)
Collected At:   $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')
"@
    Add-Section "System Information" $sysInfo
} catch {
    Add-Section "System Information" "ERROR: $_"
    Add-Issue "ERROR" "Failed to collect system information"
}

# ============================================
# 2. GPU / DISPLAY DRIVER
# ============================================
Write-Host "Collecting GPU information..." -ForegroundColor Yellow

try {
    $gpus = Get-CimInstance Win32_VideoController -ErrorAction Stop |
        Select-Object Name, DriverVersion, DriverDate, AdapterRAM, Status
    $gpuInfo = $gpus | Format-List | Out-String
    # Only count healthy adapters - virtual display drivers (Virtual Desktop,
    # streaming monitors) report Status=Error and are not real render GPUs.
    $activeGpus = @($gpus | Where-Object { $_.Status -eq 'OK' })
    if ($activeGpus.Count -gt 1) {
        $gpuInfo += "`nNote: Multiple active GPUs detected (hybrid/Optimus laptop?). The overlay creates its DX12 device on the default adapter - a mismatch with the game's adapter can cause issues.`n"
    }
    Add-Section "GPU / Display Driver" $gpuInfo
} catch {
    Add-Section "GPU / Display Driver" "ERROR: $_"
}

# ============================================
# 3. UAC STATUS
# ============================================
Write-Host "Checking UAC configuration..." -ForegroundColor Yellow

try {
    $uac = Get-ItemProperty HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System -ErrorAction Stop
    $uacEnabled = if ($uac.EnableLUA -eq 1) { "Enabled" } else { "Disabled" }
    $uacInfo = @"
UAC Status:     $uacEnabled
ConsentPrompt:  $($uac.ConsentPromptBehaviorAdmin)
"@
    Add-Section "UAC Configuration" $uacInfo

    if ($uac.EnableLUA -eq 0) {
        Add-Issue "WARNING" "UAC is disabled - may affect overlay injection"
    }
} catch {
    Add-Section "UAC Configuration" "ERROR: $_"
    Add-Issue "ERROR" "Failed to check UAC status"
}

# ============================================
# 4. USER SESSION INFORMATION
# ============================================
Write-Host "Checking user sessions..." -ForegroundColor Yellow

try {
    $sessions = quser 2>&1
    if ($LASTEXITCODE -eq 0) {
        Add-Section "Active User Sessions" ($sessions | Out-String)

        # Parse session count
        $sessionLines = ($sessions | Select-Object -Skip 1 | Measure-Object).Count
        if ($sessionLines -gt 1) {
            Add-Issue "WARNING" "Multiple user sessions detected ($sessionLines active) - this can cause shared memory isolation"
        }
    } else {
        Add-Section "Active User Sessions" "Only one session active (current user)"
    }
} catch {
    Add-Section "Active User Sessions" "ERROR: $_"
}

# ============================================
# 5. PROCESS INFORMATION
# ============================================
Write-Host "Checking helper and game processes..." -ForegroundColor Yellow

$helperProc = $null
$gameProc = $null
$helperNames = @("ef-overlay-helper", "ef-overlay-tray", "EF-MapOverlayHelper")
$gameName = "exefile"

try {
    # Find helper process
    foreach ($name in $helperNames) {
        $proc = Get-Process -Name $name -ErrorAction SilentlyContinue | Select-Object -First 1
        if ($proc) {
            $helperProc = $proc
            break
        }
    }

    # Find game process
    $gameProcAll = @(Get-Process -Name $gameName -ErrorAction SilentlyContinue)
    $gameProc = $gameProcAll | Select-Object -First 1
    if ($gameProcAll.Count -gt 1) {
        Add-Issue "WARNING" "Multiple exefile.exe processes found ($($gameProcAll.Count)) - the helper refuses to inject when more than one game client is running"
    }

    if ($helperProc -or $gameProc) {
        $procInfo = ""
        foreach ($p in @($helperProc, $gameProc)) {
            if (-not $p) { continue }
            $elev = Get-ProcessElevation -ProcId $p.Id
            $respondingNote = ""
            try {
                if (-not $p.Responding) { $respondingNote = " (NOT RESPONDING - frozen/hung)" }
            } catch {}
            $procInfo += @"
Name:           $($p.Name)$respondingNote
PID:            $($p.Id)
SessionId:      $($p.SessionId)
StartTime:      $(try { $p.StartTime } catch { 'Unknown' })
Path:           $(try { $p.Path } catch { 'Unknown' })
WorkingSet(MB): $([math]::Round($p.WorkingSet64 / 1MB, 2))
Elevation:      $elev

"@
            if ($p.Name -eq $gameName -and -not $p.Responding) {
                Add-Issue "CRITICAL" "Game process is NOT RESPONDING (frozen) - capture this report and see the freeze section at the end"
            }
        }
        Add-Section "Process Details" $procInfo

        # Check for issues
        if (-not $helperProc) {
            Add-Issue "CRITICAL" "Helper process not found - overlay cannot inject"
        }

        if (-not $gameProc) {
            Add-Issue "WARNING" "Game process (exefile.exe) not found - unable to verify injection"
        }

        if ($helperProc -and $gameProc) {
            # Check session ID mismatch
            if ($helperProc.SessionId -ne $gameProc.SessionId) {
                Add-Issue "CRITICAL" "Session ID mismatch: Helper ($($helperProc.SessionId)) vs Game ($($gameProc.SessionId)) - shared memory isolation"
            }

            # Check elevation mismatch (per-process token query)
            $helperElev = Get-ProcessElevation -ProcId $helperProc.Id
            $gameElev = Get-ProcessElevation -ProcId $gameProc.Id
            if ($helperElev -ne "Unknown" -and $gameElev -ne "Unknown" -and $helperElev -ne $gameElev) {
                Add-Issue "CRITICAL" "Elevation mismatch: Helper=$helperElev vs Game=$gameElev - most common injection failure"
            }
        }
    } else {
        Add-Section "Process Details" "CRITICAL: Neither helper nor game process found running"
        Add-Issue "CRITICAL" "No helper or game process detected - ensure both are running"
    }
} catch {
    Add-Section "Process Details" "ERROR: $_"
    Add-Issue "ERROR" "Failed to collect process information"
}

# ============================================
# 6. HELPER INSTALLATION DETECTION
# ============================================
Write-Host "Detecting helper installation type..." -ForegroundColor Yellow

try {
    $installType = "Unknown"
    $installPath = "Not found"

    if ($helperProc) {
        $installPath = try { $helperProc.Path } catch { "Unknown" }

        if ($installPath -like "*WindowsApps*") {
            $installType = "Microsoft Store (MSIX)"
        } elseif ($installPath -like "*Program Files*") {
            $installType = "Sideloaded MSIX (Development)"
        } else {
            $installType = "Standalone Build"
        }
    }

    $installInfo = @"
Installation Type: $installType
Helper Path:       $installPath
"@
    Add-Section "Helper Installation" $installInfo
} catch {
    Add-Section "Helper Installation" "ERROR: $_"
}

# ============================================
# 7. DLL INJECTION STATUS + CONFLICTING OVERLAYS
# ============================================
Write-Host "Checking DLL injection status and third-party overlays..." -ForegroundColor Yellow

# Known third-party overlay/capture hook DLLs (module name pattern -> product)
$overlayDllPatterns = @(
    @{ Pattern = "DiscordHook*";           Product = "Discord overlay" }
    @{ Pattern = "RTSSHooks*";             Product = "RivaTuner Statistics Server / MSI Afterburner" }
    @{ Pattern = "GameOverlayRenderer*";   Product = "Steam overlay" }
    @{ Pattern = "nvspcap*";               Product = "NVIDIA ShadowPlay / GeForce overlay" }
    @{ Pattern = "graphics-hook*";         Product = "OBS game capture" }
    @{ Pattern = "EOSOVH*";                Product = "Epic Games overlay" }
    @{ Pattern = "ow-graphics*";           Product = "Overwolf" }
    @{ Pattern = "owclient*";              Product = "Overwolf" }
    @{ Pattern = "fraps*";                 Product = "Fraps" }
    @{ Pattern = "bdcam*";                 Product = "Bandicam" }
    @{ Pattern = "action_x*";              Product = "Mirillis Action!" }
    @{ Pattern = "medal-hook*";            Product = "Medal.tv" }
    @{ Pattern = "XSplitGameSDK*";         Product = "XSplit" }
)

$foreignOverlays = @()

try {
    if ($gameProc) {
        $moduleInfo = "Checking loaded modules in game process...`n"

        try {
            # Attempt to query process modules (may fail without elevation)
            $modules = Get-Process -Id $gameProc.Id -Module -ErrorAction SilentlyContinue

            if ($modules) {
                $overlayDll = $modules | Where-Object { $_.ModuleName -like "*ef-overlay*.dll" }

                if ($overlayDll) {
                    $moduleInfo += "`nEF OVERLAY DLL FOUND:`n"
                    $moduleInfo += $overlayDll | Format-List ModuleName, FileName, Size | Out-String
                } else {
                    $moduleInfo += "`nEF overlay DLL NOT found in process modules`n"
                    $moduleInfo += "Loaded modules: $($modules.Count) total`n"
                    Add-Issue "CRITICAL" "Overlay DLL not loaded into game process - injection failed or not attempted"
                }

                # Scan for third-party overlay hook DLLs (top freeze suspect)
                foreach ($entry in $overlayDllPatterns) {
                    $hit = $modules | Where-Object { $_.ModuleName -like $entry.Pattern }
                    if ($hit) {
                        $foreignOverlays += $entry.Product
                        $moduleInfo += "`nTHIRD-PARTY OVERLAY HOOK: $($entry.Product)`n"
                        $moduleInfo += ($hit | Format-List ModuleName, FileName | Out-String)
                    }
                }
                if ($foreignOverlays.Count -gt 0) {
                    $uniqueOverlays = $foreignOverlays | Select-Object -Unique
                    Add-Issue "WARNING" "Third-party overlay hooks inside the game process: $($uniqueOverlays -join ', ') - overlay conflicts are the top suspect for game freezes on Start Overlay"
                } else {
                    $moduleInfo += "`nNo known third-party overlay hook DLLs detected in the game process.`n"
                }
            } else {
                $moduleInfo += "`nUnable to enumerate process modules (may require elevation)`n"
                $moduleInfo += "Recommendation: Re-run this script from an elevated (Run as administrator) PowerShell for a complete module list`n"
            }
        } catch {
            $moduleInfo += "`nERROR querying modules: $_`n"
            $moduleInfo += "Recommendation: Run script as Administrator or use Process Explorer`n"
        }

        Add-Section "DLL Injection Status & Overlay Conflicts" $moduleInfo
    } else {
        Add-Section "DLL Injection Status & Overlay Conflicts" "Game process not running - cannot verify DLL status"
    }
} catch {
    Add-Section "DLL Injection Status & Overlay Conflicts" "ERROR: $_"
}

# ============================================
# 8. OVERLAY / CAPTURE SOFTWARE RUNNING
# ============================================
Write-Host "Checking for running overlay/capture software..." -ForegroundColor Yellow

try {
    $overlayApps = @(
        @{ Names = @("Discord", "DiscordPTB", "DiscordCanary"); Product = "Discord" }
        @{ Names = @("RTSS");                                    Product = "RivaTuner Statistics Server" }
        @{ Names = @("MSIAfterburner");                          Product = "MSI Afterburner" }
        @{ Names = @("obs64", "obs32");                          Product = "OBS Studio" }
        @{ Names = @("Overwolf");                                Product = "Overwolf" }
        @{ Names = @("Medal");                                   Product = "Medal.tv" }
        @{ Names = @("NVIDIA Share", "nvsphelper64", "NVIDIA Overlay"); Product = "NVIDIA overlay/ShadowPlay" }
        @{ Names = @("GameBar", "GameBarFTServer");              Product = "Xbox Game Bar" }
        @{ Names = @("Fraps");                                   Product = "Fraps" }
        @{ Names = @("bdcam");                                   Product = "Bandicam" }
        @{ Names = @("XSplit.Core");                             Product = "XSplit" }
    )

    $runningOverlayApps = @()
    foreach ($app in $overlayApps) {
        foreach ($n in $app.Names) {
            if (Get-Process -Name $n -ErrorAction SilentlyContinue) {
                $runningOverlayApps += $app.Product
                break
            }
        }
    }
    $runningOverlayApps = $runningOverlayApps | Select-Object -Unique

    if ($runningOverlayApps.Count -gt 0) {
        $appsInfo = "Overlay/capture software currently running:`n  - " + ($runningOverlayApps -join "`n  - ") + "`n"
        $appsInfo += "`nNote: these often hook DirectX Present in games. If the game freezes when starting the EF overlay, try disabling these overlays (or exiting the apps) one at a time and retry.`n"
    } else {
        $appsInfo = "No known overlay/capture software detected running.`n"
    }
    Add-Section "Overlay / Capture Software Running" $appsInfo
} catch {
    Add-Section "Overlay / Capture Software Running" "ERROR: $_"
}

# ============================================
# 9. HELPER LOGS
# ============================================
Write-Host "Collecting helper logs..." -ForegroundColor Yellow

try {
    $logPath = "$env:LOCALAPPDATA\EFOverlay\logs"
    $logFiles = Get-ChildItem -Path $logPath -Filter "*.log" -ErrorAction SilentlyContinue |
        Sort-Object LastWriteTime -Descending

    if ($logFiles) {
        $latestLog = $logFiles | Select-Object -First 1
        $logInfo = @"
Log Directory:  $logPath
Latest Log:     $($latestLog.Name)
Last Modified:  $($latestLog.LastWriteTime)
Size:           $([math]::Round($latestLog.Length / 1KB, 2)) KB
"@

        if ($IncludeLogs) {
            $logInfo += "`n`n--- LOG CONTENTS (Last 200 lines) ---`n"
            $logContent = Get-Content -Path $latestLog.FullName -Tail 200 -ErrorAction SilentlyContinue
            $logInfo += $logContent -join "`n"
        } else {
            $logInfo += "`n`nNote: Use -IncludeLogs parameter to include full log contents"

            # Extract key errors/warnings
            $logContent = Get-Content -Path $latestLog.FullName -Tail 100 -ErrorAction SilentlyContinue
            $errors = $logContent | Where-Object { $_ -match "\[error\]|\[critical\]" }
            $warnings = $logContent | Where-Object { $_ -match "\[warn\]" }

            if ($errors) {
                $logInfo += "`n`n--- Recent Errors (Last 10) ---`n"
                $logInfo += ($errors | Select-Object -Last 10) -join "`n"
            }

            if ($warnings) {
                $logInfo += "`n`n--- Recent Warnings (Last 10) ---`n"
                $logInfo += ($warnings | Select-Object -Last 10) -join "`n"
            }
        }

        Add-Section "Helper Logs" $logInfo

        # Check for common error patterns
        $fullLog = Get-Content -Path $latestLog.FullName -ErrorAction SilentlyContinue
        if ($fullLog -match "Failed to create shared memory") {
            Add-Issue "CRITICAL" "Helper failed to create shared memory mapping"
        }
        if ($fullLog -match "Injection failed") {
            Add-Issue "CRITICAL" "DLL injection explicitly failed - check log for details"
        }
        if ($fullLog -match "Access denied") {
            Add-Issue "CRITICAL" "Access denied error detected - possible permission issue"
        }
    } else {
        # Helper versions up to v1.1.1 do NOT write log files - absence is expected, not an error.
        Add-Section "Helper Logs" "No log files found at $logPath`nThis is EXPECTED for helper versions up to v1.1.1 (they do not write log files)."
    }
} catch {
    Add-Section "Helper Logs" "ERROR: $_"
}

# ============================================
# 10. ANTIVIRUS / SECURITY SOFTWARE
# ============================================
Write-Host "Checking security software..." -ForegroundColor Yellow

try {
    $avInfo = ""

    # Windows Defender status
    try {
        $defender = Get-MpComputerStatus -ErrorAction SilentlyContinue
        if ($defender) {
            $avInfo += @"
Windows Defender:
  Real-time Protection: $($defender.RealTimeProtectionEnabled)
  Tamper Protection:    $($defender.IsTamperProtected)
  Last Scan:            $($defender.QuickScanEndTime)

"@
        }
    } catch {
        $avInfo += "Windows Defender: Unable to query status`n"
    }

    # Registered AV products via Security Center (fast; replaces the old
    # Win32_Product scan, which is slow and can trigger MSI reconfiguration)
    $avProducts = $null
    try {
        $avProducts = Get-CimInstance -Namespace root/SecurityCenter2 -ClassName AntiVirusProduct -ErrorAction Stop |
            Select-Object displayName, productState
    } catch {}

    if ($avProducts) {
        $avInfo += "`nRegistered Antivirus Products (Security Center):`n"
        $avInfo += $avProducts | Format-Table -AutoSize | Out-String
        $thirdParty = $avProducts | Where-Object { $_.displayName -notmatch "Windows Defender|Microsoft Defender" }
        if ($thirdParty) {
            Add-Issue "WARNING" "Third-party security software detected ($(($thirdParty.displayName | Select-Object -Unique) -join ', ')) - may block or stall DLL injection"
        }
    } else {
        $avInfo += "`nUnable to query Security Center for registered antivirus products`n"
    }

    Add-Section "Security Software" $avInfo
} catch {
    Add-Section "Security Software" "ERROR: $_"
}

# ============================================
# 11. HELPER API STATUS
# ============================================
Write-Host "Testing helper API connectivity..." -ForegroundColor Yellow

try {
    $apiResults = ""
    $apiBaseUrl = "http://127.0.0.1:38765"

    # /health is the helper's only unauthenticated status endpoint (there is
    # no /api/status - do not probe invented endpoints, a false FAILED line
    # derails support triage)
    try {
        $health = Invoke-RestMethod -Uri "$apiBaseUrl/health" -TimeoutSec 5 -ErrorAction Stop
        $apiResults += "Health Endpoint: OK`n"
        $apiResults += $health | ConvertTo-Json -Depth 2
        $apiResults += "`n"

        if ($health.has_overlay_state -eq $false) {
            Add-Issue "WARNING" "Helper reports no overlay state ingested yet - EF-Map may not be connected to the helper"
        }
        if ($health.app_version) {
            $apiResults += "`nHelper version: $($health.app_version)`n"
        }
    } catch {
        $apiResults += "Health Endpoint: FAILED - $($_.Exception.Message)`n"
        Add-Issue "CRITICAL" "Helper HTTP API not responding - helper may not be running"
    }

    Add-Section "Helper API Status" $apiResults
} catch {
    Add-Section "Helper API Status" "ERROR: $_"
}

# ============================================
# 12. SHARED MEMORY DIAGNOSTIC
# ============================================
Write-Host "Checking shared memory status..." -ForegroundColor Yellow

$shmemInfo = @"
Note: Verifying shared memory existence requires Process Explorer (Sysinternals)
or elevated PowerShell with handle enumeration tools.

Expected shared memory name: Local\EFOverlaySharedState
Expected location: \Sessions\<N>\BaseNamedObjects\Local\EFOverlaySharedState

Manual verification steps:
1. Download Process Explorer from Microsoft Sysinternals
2. Find ef-overlay-helper.exe process
3. Press Ctrl+H to show handles
4. Search for "EFOverlaySharedState"
5. Note the session ID in the path
6. Compare to game process (exefile.exe) session ID

If session IDs don't match: Elevation/session isolation issue (see Process Details section)
"@

Add-Section "Shared Memory Diagnostic" $shmemInfo

# ============================================
# GENERATE SUMMARY
# ============================================
Write-Host "`nGenerating summary..." -ForegroundColor Yellow

$summary = @"
========================================
  DIAGNOSTIC SUMMARY
========================================
Total Issues Found: $($script:Issues.Count)

"@

if ($script:Issues.Count -eq 0) {
    $summary += "No obvious issues detected. If overlay still fails:`n"
    $summary += "- Verify DirectX 12 mode (overlay doesn't support DX11/Vulkan)`n"
    $summary += "- Try closing all processes and restarting both helper and game`n"
    $summary += "- If the game FREEZES on Start Overlay, see the freeze section below`n"
} else {
    $summary += "DETECTED ISSUES:`n"
    $summary += ($script:Issues -join "`n")
    $summary += "`n`n"

    # Add recommendations based on issues
    $summary += "RECOMMENDATIONS:`n"

    if ($script:Issues -match "Elevation mismatch") {
        $summary += @"
1. MOST LIKELY FIX - Elevation Mismatch:
   - Close helper completely
   - Close game completely
   - Launch helper WITHOUT "Run as administrator"
   - Launch game WITHOUT "Run as administrator"
   - Click "Start Overlay" in helper UI
   - Accept UAC prompt if it appears

"@
    }

    if ($script:Issues -match "Third-party overlay hooks") {
        $summary += @"
2. OVERLAY CONFLICT (top suspect for game freezes):
   - Another overlay is already hooked into the game's renderer
   - Disable in-game overlays one at a time, restarting the game between tries:
     * Discord: Settings > Activity Settings > Game Overlay > off
     * Steam: Settings > In Game > Enable Steam Overlay > off
     * NVIDIA App/GeForce Experience: disable in-game overlay
     * MSI Afterburner / RivaTuner: exit RTSS
     * OBS: avoid "Game Capture" source while testing (use Display Capture)
   - Retry "Start Overlay" after each change

"@
    }

    if ($script:Issues -match "Session ID mismatch") {
        $summary += @"
3. Session Isolation Issue:
   - Ensure no other Windows users are logged in
   - Log out of all Remote Desktop sessions
   - Both helper and game must run under the same user account

"@
    }

    if ($script:Issues -match "DLL not loaded|Overlay DLL not loaded") {
        $summary += @"
4. DLL Injection Failed:
   - Verify game is running in DirectX 12 mode
   - Ensure antivirus isn't blocking injection
   - Accept the UAC prompt when clicking "Start Overlay"

"@
    }

    if ($script:Issues -match "security software") {
        $summary += @"
5. Security Software Interference:
   - Temporarily disable antivirus real-time protection
   - Add exceptions for:
     * ef-overlay-helper.exe
     * ef-overlay.dll
     * ef-overlay-injector.exe
     * exefile.exe (allow DLL injection)

"@
    }
}

$summary += @"

========================================
  IF THE GAME FREEZES ON "START OVERLAY"
========================================
The overlay currently has no log file inside the game, so a freeze leaves no
trace on disk. To capture what happened at the moment of the freeze:

1. Download DebugView from Microsoft Sysinternals:
   https://learn.microsoft.com/sysinternals/downloads/debugview
2. Run DebugView as Administrator
3. Menu: Capture > enable "Capture Global Win32"
4. Start the game, then click "Start Overlay" in the helper
5. When the game freezes, in DebugView: File > Save As... and save the log
6. EMAIL that file to support@ef-map.com together with this report

IMPORTANT: DebugView logs can capture the game launcher's command line,
which includes your EVE Frontier login tokens. NEVER post a DebugView log
in Discord or anywhere public - email it to support@ef-map.com only.

Also helpful: which other overlays you use (Discord/Steam/NVIDIA/RTSS/OBS),
and whether the freeze happens with those disabled.

========================================
  NEXT STEPS
========================================
The report opens in Notepad automatically and is highlighted in an
Explorer window so you can attach it easily.

1. Send the report file to support@ef-map.com, or post it in the
   EF-Map Discord (invite: https://discord.gg/TxpyHZrmFq)
   (This report file is fine to post. DebugView freeze logs are NOT -
   they can contain your login tokens; email those to support only.)
2. Include a short description of what happens when you click "Start Overlay"
3. Mention if you see any UAC prompts
4. Note if the helper tray icon shows any error messages

Report saved to: $OutputFile
========================================
"@

# Add summary at the beginning of report
$fullReport = $summary + "`n`n" + ($script:Report -join "")

# ============================================
# SAVE REPORT
# ============================================
$saved = $false
try {
    $fullReport | Out-File -FilePath $OutputFile -Encoding UTF8
    $saved = $true
    Write-Host "`nDiagnostic report saved to:" -ForegroundColor Green
    Write-Host $OutputFile -ForegroundColor Cyan

    # Display summary on screen
    Write-Host "`n$summary" -ForegroundColor White
} catch {
    Write-Host "`nERROR: Failed to save report: $_" -ForegroundColor Red
    Write-Host "`nDumping report to console instead:`n" -ForegroundColor Yellow
    Write-Host $fullReport
}

if ($saved) {
    # Open the report and highlight the file so the user never has to hunt for it
    try { Start-Process notepad.exe -ArgumentList "`"$OutputFile`"" } catch {}
    try { Start-Process explorer.exe -ArgumentList "/select,`"$OutputFile`"" } catch {}
    Write-Host "`nThe report has been opened in Notepad and highlighted in Explorer." -ForegroundColor Green
    Write-Host "Send that file to support@ef-map.com or the EF-Map Discord (https://discord.gg/TxpyHZrmFq)." -ForegroundColor Green
    Write-Host "If you captured a DebugView freeze log, EMAIL it to support only - it can contain your login tokens. Do not post it publicly." -ForegroundColor Yellow
}

Write-Host "`nDiagnostic collection complete!" -ForegroundColor Green

# Keep the window open when launched by double-click / "Run with PowerShell"
# (harmless no-op inside an existing terminal; guarded for non-interactive hosts)
try { Read-Host "`nPress Enter to close this window" | Out-Null } catch {}