<#
.SYNOPSIS
  Runs one scripted scenario of the game with no window and no person at the keyboard, then reports what it wrote.

.DESCRIPTION
  Launches UnrealEditor.exe in -game mode with -RenderOffscreen (real GPU rendering, no window shown) and
  -DescentScenario=<Name>. The scenario (see Source\TheDescent\Debug\DescentScenario.h) drives the game, takes
  screenshots to Saved\Shots\<scenario>_<label>.png, dumps state to Saved\State\<scenario>_<label>.json and quits by
  itself; this script waits for that. If the time limit passes it stops THE PROCESS IT STARTED (and that process's
  children), nothing else - an editor you have open is never touched.

  The game runs with a FIXED TIME STEP (-UseFixedTimeStep -FPS=30 by default): every frame advances the world by
  exactly 1/30 s, whatever the machine's frame rate, so a scenario's results (sim clock, positions after N seconds)
  do not depend on the PC. -Fps changes the step; -RealTime turns the fixed step off (frames use real time).

  Then it prints: the files this run wrote (with image sizes and the luminance numbers of each shot's sidecar
  JSON), the last error lines of the log, and one result line.
  PASS needs: process exit code 0 AND the log line "DESCENT_SCENARIO_RESULT PASS".

  Log of the run: Saved\Logs\scenario_<Name>.log

.EXAMPLE
  powershell -NoProfile -ExecutionPolicy Bypass -File Tools\run_scenario.ps1 -Name kazah_showcase
  powershell -NoProfile -ExecutionPolicy Bypass -File Tools\run_scenario.ps1 -Name smoke -ResX 1920 -ResY 1080 -TimeoutSec 120
  Exit code 0 = PASS, 1 = FAIL.
#>
[CmdletBinding()]
param(
    [Parameter(Mandatory = $true)][string]$Name,
    # Wall-clock limit for the whole process, including engine start-up and shader compilation. A cold shader
    # cache can take several minutes; a warm one starts the scenario in about 20 s.
    [int]$TimeoutSec = 300,
    [int]$ResX = 1280,
    [int]$ResY = 720,
    # Frames per second of the fixed time step (every frame advances the game by exactly 1/Fps s).
    [int]$Fps = 30,
    # Use real frame times instead of the fixed step.
    [switch]$RealTime
)
$ErrorActionPreference = 'Stop'
$ProjectRoot = Split-Path -Parent $PSScriptRoot
$Uproject = Join-Path $ProjectRoot 'TheDescent.uproject'
$Editor = 'E:\Tools\UE_5.8\Engine\Binaries\Win64\UnrealEditor.exe'
$LogDir = Join-Path $ProjectRoot 'Saved\Logs'
$LogFile = Join-Path $LogDir ("scenario_{0}.log" -f $Name)
$ShotDir = Join-Path $ProjectRoot 'Saved\Shots'
$StateDir = Join-Path $ProjectRoot 'Saved\State'

if (-not (Test-Path $Editor)) { Write-Host "SCENARIO FAIL: $Editor not found"; exit 1 }
New-Item -ItemType Directory -Force -Path $LogDir, $ShotDir, $StateDir | Out-Null
if (Test-Path $LogFile) { Remove-Item $LogFile -Force }

function Get-PngSize([string]$Path) {
    try {
        $fs = [System.IO.File]::OpenRead($Path)
        try {
            $b = New-Object byte[] 24
            [void]$fs.Read($b, 0, 24)
        } finally { $fs.Close() }
        # IHDR width/height are big-endian 32-bit at offsets 16 and 20; widen before shifting (bytes would overflow).
        $w = ([int]$b[16] -shl 24) -bor ([int]$b[17] -shl 16) -bor ([int]$b[18] -shl 8) -bor [int]$b[19]
        $h = ([int]$b[20] -shl 24) -bor ([int]$b[21] -shl 16) -bor ([int]$b[22] -shl 8) -bor [int]$b[23]
        return "{0}x{1}" -f $w, $h
    } catch { return '?' }
}

$env:UE_SDKS_ROOT = 'D:\HADAL - The Descent\.tools\AutoSDK'
$argList = @(
    ('"' + $Uproject + '"'),
    '-game', '-windowed', "-ResX=$ResX", "-ResY=$ResY", '-RenderOffscreen',
    '-unattended', '-nosplash', '-nosound', '-nopause', '-NoLiveCoding', '-log',
    ('-abslog="' + $LogFile + '"'),
    "-DescentScenario=$Name"
)
if (-not $RealTime) { $argList += @('-UseFixedTimeStep', "-FPS=$Fps") }

$startTime = Get-Date
$sw = [System.Diagnostics.Stopwatch]::StartNew()
$proc = Start-Process -FilePath $Editor -ArgumentList $argList -PassThru -WindowStyle Hidden
$ownPid = $proc.Id
$stepNote = if ($RealTime) { 'real-time frames' } else { "fixed step 1/$Fps s" }
Write-Host ("scenario '{0}': started process {1}, limit {2}s, {3}x{4}, {5}" -f $Name, $ownPid, $TimeoutSec, $ResX, $ResY, $stepNote)

$timedOut = $false
if (-not $proc.WaitForExit($TimeoutSec * 1000)) {
    $timedOut = $true
    Write-Host ("scenario '{0}': time limit reached, stopping process {1} (the one this script started)" -f $Name, $ownPid)
    # /T takes this process's own children with it (shader workers, crash reporter), nothing else.
    & taskkill.exe /PID $ownPid /T /F | Out-Null
    [void]$proc.WaitForExit(15000)
}
$sw.Stop()
$exitCode = if ($proc.HasExited) { $proc.ExitCode } else { -1 }

# --- what the run produced ------------------------------------------------------------------------------
$prefix = "{0}_" -f $Name
$shots = Get-ChildItem -Path $ShotDir -Filter "$prefix*.png" -ErrorAction SilentlyContinue | Where-Object { $_.LastWriteTime -ge $startTime }
$states = Get-ChildItem -Path $StateDir -Filter "$prefix*.json" -ErrorAction SilentlyContinue | Where-Object { $_.LastWriteTime -ge $startTime }
Write-Host "screenshots:"
if ($shots) {
    foreach ($s in $shots) {
        Write-Host ("  {0}  {1}  {2:N0} bytes" -f $s.FullName, (Get-PngSize $s.FullName), $s.Length)
        # The sidecar next to the PNG: luminance statistics (sRGB-encoded 0..1), written by every Shot.
        $side = [System.IO.Path]::ChangeExtension($s.FullName, '.json')
        if (Test-Path $side) {
            try {
                $j = Get-Content $side -Raw | ConvertFrom-Json
                Write-Host ("      mean_luma={0}  centre_luma={1}  p99_luma={2}  non_black={3}  mean_rgb=[{4}]" -f $j.mean_luma, $j.centre_luma, $j.p99_luma, $j.non_black, ($j.mean_rgb -join ', '))
            } catch { Write-Host "      (sidecar unreadable)" }
        } else { Write-Host "      (no sidecar .json)" }
    }
} else { Write-Host "  (none)" }
Write-Host "state dumps:"
if ($states) { foreach ($s in $states) { Write-Host ("  {0}  {1:N0} bytes" -f $s.FullName, $s.Length) } } else { Write-Host "  (none)" }

$logLines = @()
if (Test-Path $LogFile) { $logLines = Get-Content $LogFile -ErrorAction SilentlyContinue }
$resultLine = $logLines | Where-Object { $_ -match 'DESCENT_SCENARIO_RESULT' } | Select-Object -Last 1
# The engine's own ToolsetRegistry plugin prints a Python traceback ("no attribute 'PythonTestRunner'") at every
# start-up of this engine build. It is not ours and never changes the outcome, so it is left out of this list.
$engineNoise = 'PythonTestRunner|ToolsetRegistry|init_unreal\.py|LogPython: Error: +\^+|LogPython: Error: Traceback'
$errLines = $logLines | Where-Object { $_ -match ': Error: |Fatal error|Assertion failed|Ensure condition failed|Unhandled Exception|LogMaterial: .*(fail|error)|Shader.*(fail|error)' -and $_ -notmatch $engineNoise } |
    ForEach-Object { $_ -replace '^\[[0-9.:\-]+\]\[\s*\d+\]', '' } | Select-Object -Unique | Select-Object -Last 12
Write-Host "last error lines of the log:"
if ($errLines) { $errLines | ForEach-Object { Write-Host ("  " + $_.Substring(0, [Math]::Min($_.Length, 260))) } } else { Write-Host "  (none)" }
if ($resultLine) { Write-Host ("scenario result line: " + ($resultLine -replace '^\[[0-9.:\-]+\]\[\s*\d+\]', '')) }
Write-Host ("log: {0}" -f $LogFile)

$secs = [math]::Round($sw.Elapsed.TotalSeconds, 1)
$pass = ($exitCode -eq 0) -and $resultLine -and ($resultLine -match 'DESCENT_SCENARIO_RESULT PASS')
if ($pass) {
    Write-Host ("SCENARIO PASS  {0}  {1}s" -f $Name, $secs)
    exit 0
}
$why = if ($timedOut) { 'timed out' } elseif (-not $resultLine) { 'no result line in the log (crashed or exited early)' } else { 'scenario reported failure' }
Write-Host ("SCENARIO FAIL  {0}  {1}s  exit={2}  ({3})" -f $Name, $secs, $exitCode, $why)
exit 1