<#
.SYNOPSIS
    Before/after benchmark for "Skip unrelated parameters when checking for missing mandatory parameters".

.DESCRIPTION
    Runs the Before and After pwsh builds in alternating processes (to spread out machine noise),
    and in each process measures every case in-process with [Diagnostics.Stopwatch] and
    [GC]::GetTotalAllocatedBytes. Each process reports the best of $Reps repetitions; the script
    then prints the median across $Rounds processes as two markdown tables.

.EXAMPLE
    ./bench-where-object.ps1 -Before ~/ps-master/release/pwsh -After ~/ps-patched/release/pwsh
    (Build each with: Start-PSBuild -Configuration Release -Output release)
#>
param(
    [Parameter(Mandatory)] [string] $Before,
    [Parameter(Mandatory)] [string] $After,
    [int] $Rounds = 5,
    [int] $Reps = 5
)

# Code that runs inside each child pwsh process. Prints one JSON line.
$worker = @'
param([int] $Reps)
$objs = 1..50000 | ForEach-Object { [pscustomobject]@{ Id = $_; Name = "item$_"; Tag = ($_ % 10) } }
$cases = [ordered]@{
    '`1..200000 | Where-Object { $_ % 2 }`'               = @{ N = 200000; S = { 1..200000 | Where-Object { $_ % 2 } | Out-Null } }
    '`$objs | Where-Object Tag -eq 3` (50k objects)'      = @{ N = 50000;  S = { $objs | Where-Object Tag -eq 3 | Out-Null } }
    '`1..200000 | ForEach-Object { $_ }`'                 = @{ N = 200000; S = { 1..200000 | ForEach-Object { $_ } | Out-Null } }
}
$out = [ordered]@{}
foreach ($name in $cases.Keys) {
    $c = $cases[$name]
    & $c.S; & $c.S                                   # warm up (JIT, caches)
    $bestMs = [double]::MaxValue; $bestBytes = [long]::MaxValue
    for ($i = 0; $i -lt $Reps; $i++) {
        [GC]::Collect(); [GC]::WaitForPendingFinalizers()
        $a0 = [GC]::GetTotalAllocatedBytes($true)
        $sw = [Diagnostics.Stopwatch]::StartNew()
        & $c.S
        $sw.Stop()
        $a1 = [GC]::GetTotalAllocatedBytes($true)
        $bestMs = [Math]::Min($bestMs, $sw.Elapsed.TotalMilliseconds)
        $bestBytes = [Math]::Min($bestBytes, $a1 - $a0)
    }
    $out[$name] = @{ ms = $bestMs; n = $c.N; bytes = $bestBytes }
}
$out | ConvertTo-Json -Compress -Depth 3
'@
$workerPath = Join-Path ([IO.Path]::GetTempPath()) "bench-where-object-worker.ps1"
Set-Content -Path $workerPath -Value $worker

$results = @{ Before = @(); After = @() }
for ($r = 1; $r -le $Rounds; $r++) {
    foreach ($side in 'Before', 'After') {
        $exe = if ($side -eq 'Before') { $Before } else { $After }
        Write-Host "round $r/$Rounds  $side"
        $json = & $exe -NoProfile -NonInteractive -File $workerPath -Reps $Reps | Select-Object -Last 1
        $results[$side] += , ($json | ConvertFrom-Json -AsHashtable)
    }
}

function Median([double[]] $v) { $s = $v | Sort-Object; if ($s.Count % 2) { $s[[int][Math]::Floor($s.Count / 2)] } else { ($s[$s.Count / 2 - 1] + $s[$s.Count / 2]) / 2 } }
function Pct($a, $b) { '{0:+0;-0;0}%' -f (100 * ($b - $a) / $a) }

$names = $results.Before[0].Keys
''
"Whole pipeline, median of $Rounds alternating process runs, each the best of $Reps repetitions:"
''
'| Command | Before | After | Change |'
'|---|---:|---:|---:|'
foreach ($n in $names) {
    $b = Median ($results.Before | ForEach-Object { $_[$n].ms }); $a = Median ($results.After | ForEach-Object { $_[$n].ms })
    '| {0} | {1:N0} ms | {2:N0} ms | {3} |' -f ($n -replace '\|', '\|'), $b, $a, (Pct $b $a)
}
''
'Per object, measured in-process with `[GC]::GetTotalAllocatedBytes` and `[Diagnostics.Stopwatch]`:'
''
'| Command | Allocated before | Allocated after | Change | Time before | Time after | Change |'
'|---|---:|---:|---:|---:|---:|---:|'
foreach ($n in $names) {
    $cnt = $results.Before[0][$n].n
    $bb = Median ($results.Before | ForEach-Object { $_[$n].bytes / $cnt }); $ab = Median ($results.After | ForEach-Object { $_[$n].bytes / $cnt })
    $bt = Median ($results.Before | ForEach-Object { $_[$n].ms * 1000 / $cnt }); $at = Median ($results.After | ForEach-Object { $_[$n].ms * 1000 / $cnt })
    $bAll = $results.Before | ForEach-Object { [math]::Round($_[$n].bytes / $cnt) } | Sort-Object -Unique
    $aAll = $results.After  | ForEach-Object { [math]::Round($_[$n].bytes / $cnt) } | Sort-Object -Unique
    '| {0} | {1:N0} B | {2:N0} B | {3} | {4:N2} µs | {5:N2} µs | {6} |' -f ($n -replace '\|', '\|'), $bb, $ab, (Pct $bb $ab), $bt, $at, (Pct $bt $at)
    if ($bAll.Count -gt 1 -or $aAll.Count -gt 1) { Write-Host "note: allocation varied across runs for $n" }
}
Remove-Item $workerPath -ErrorAction SilentlyContinue