# PowerShell script to send 100 GET requests to http://localhost/traffic/next using parallel execution
# This script uses runspaces for maximum performance

# Target URL
$url = "http://localhost/traffic/next"

# Number of requests to send
$requestCount = 1000

# Maximum number of concurrent threads
$maxThreads = 32  # Adjust based on your system's capabilities

Write-Host "Sending $requestCount GET requests to $url using parallel execution..."

# Create runspace pool
$runspacePool = [runspacefactory]::CreateRunspacePool(1, $maxThreads)
$runspacePool.Open()

# Create a script block for making the request
$scriptBlock = {
    param($url, $id)

    # Use Stopwatch for more precise timing
    $stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
    try {
        $response = Invoke-WebRequest -Uri $url -Method Get -UseBasicParsing -ErrorAction Stop
        $stopwatch.Stop()
        $timeMs = $stopwatch.Elapsed.TotalMilliseconds

        # Return result object
        [PSCustomObject]@{
            RequestId = $id
            StatusCode = $response.StatusCode
            ResponseTimeMs = $timeMs
            Success = $true
            Error = $null
        }
    }
    catch {
        $stopwatch.Stop()
        $timeMs = $stopwatch.Elapsed.TotalMilliseconds

        # Return error object
        [PSCustomObject]@{
            RequestId = $id
            StatusCode = 0
            ResponseTimeMs = $timeMs
            Success = $false
            Error = $_.Exception.Message
        }
    }
}

# Measure total execution time
$totalStopwatch = [System.Diagnostics.Stopwatch]::StartNew()

# Create array for runspace jobs
$runspaces = @()

# Start all requests in parallel
for ($i = 1; $i -le $requestCount; $i++) {
    $runspace = [powershell]::Create().AddScript($scriptBlock).AddArgument($url).AddArgument($i)
    $runspace.RunspacePool = $runspacePool

    $runspaces += [PSCustomObject]@{
        Runspace = $runspace
        Status = $runspace.BeginInvoke()
        Id = $i
    }
}

# Collect results
$results = @()
do {
    # Check for completed runspaces
    foreach ($runspace in ($runspaces | Where-Object { $_.Status.IsCompleted -eq $true })) {
        $result = $runspace.Runspace.EndInvoke($runspace.Status)
        $results += $result

        # Remove from pending runspaces
        $runspaces = $runspaces | Where-Object { $_.Id -ne $runspace.Id }

        # Display result (optional)
        if ($result.Success) {
            Write-Host "Request $($result.RequestId) complete: $($result.ResponseTimeMs.ToString("0.00")) ms" -ForegroundColor Green
        }
        else {
            Write-Host "Request $($result.RequestId) failed: $($result.Error)" -ForegroundColor Red
        }
    }

    # Small sleep to prevent CPU thrashing
    Start-Sleep -Milliseconds 10

} while ($runspaces.Count -gt 0)

# Stop timing
$totalStopwatch.Stop()
$totalTimeSeconds = $totalStopwatch.Elapsed.TotalSeconds

# Calculate statistics
$successResults = $results | Where-Object { $_.Success -eq $true }
$failureCount = ($results | Where-Object { $_.Success -eq $false }).Count
$successCount = $successResults.Count

if ($successCount -gt 0) {
    $avgResponseTime = ($successResults | Measure-Object -Property ResponseTimeMs -Average).Average
    $minResponseTime = ($successResults | Measure-Object -Property ResponseTimeMs -Minimum).Minimum
    $maxResponseTime = ($successResults | Measure-Object -Property ResponseTimeMs -Maximum).Maximum
    $requestsPerSecond = $requestCount / $totalTimeSeconds
}

# Display summary
Write-Host "`n--- Performance Summary ---"
Write-Host "Total Requests: $requestCount"
Write-Host "Successful: $successCount" -ForegroundColor Green
if ($failureCount -gt 0) {
    Write-Host "Failed: $failureCount" -ForegroundColor Red
}
Write-Host "Total Time: $($totalTimeSeconds.ToString("0.00")) seconds"
Write-Host "Requests/second: $($requestsPerSecond.ToString("0.00"))"

if ($successCount -gt 0) {
    Write-Host "`n--- Response Time (ms) ---"
    Write-Host "Average: $($avgResponseTime.ToString("0.00")) ms"
    Write-Host "Minimum: $($minResponseTime.ToString("0.00")) ms"
    Write-Host "Maximum: $($maxResponseTime.ToString("0.00")) ms"
}

# Clean up resources
$runspacePool.Close()
$runspacePool.Dispose()