# -----------------------------------------------------------------------------


# 1. 成果物および状態をカプセル化するクラス定義


# -----------------------------------------------------------------------------

class MonitorResult {
    [string]$ComputerName
    [bool]$IsPingSuccess
    [bool]$IsPortOpen
    [int]$TargetPort
    [long]$ResponseTimeMs
    [string]$ErrorMessage
    [datetime]$Timestamp

    MonitorResult([string]$computerName, [int]$port) {
        $this.ComputerName = $computerName
        $this.TargetPort   = $port
        $this.Timestamp    = [DateTime]::Now
    }
}

class NetworkNode {
    [string]$ComputerName
    [int]$TargetPort
    [int]$TimeoutMs

    # コンストラクタ

    NetworkNode([string]$computerName, [int]$targetPort, [int]$timeoutMs) {
        if ([string]::IsNullOrEmpty($computerName)) {
            throw [System.ArgumentNullException]::new("ComputerName cannot be null or empty.")
        }
        $this.ComputerName = $computerName
        $this.TargetPort   = $targetPort
        $this.TimeoutMs    = $timeoutMs
    }

    # 診断メソッド（例外処理を内部で完結）

    [MonitorResult] TestNode() {
        $result = [MonitorResult]::new($this.ComputerName, $this.TargetPort)
        $ping = [System.Net.NetworkInformation.Ping]::new()

        try {

            # 1. Pingによる疎通確認

            $pingReply = $ping.Send($this.ComputerName, $this.TimeoutMs)
            if ($pingReply.Status -eq [System.Net.NetworkInformation.IPStatus]::Success) {
                $result.IsPingSuccess = $true
                $result.ResponseTimeMs = $pingReply.RoundtripTime
            } else {
                $result.IsPingSuccess = $false
                $result.ErrorMessage = "Ping Status: $($pingReply.Status)"
                return $result
            }

            # 2. TCPポート開放確認 (.NET TcpClientを使用)

            $tcpClient = [System.Net.Sockets.TcpClient]::new()
            $connectAsync = $tcpClient.BeginConnect($this.ComputerName, $this.TargetPort, $null, $null)
            $waitHandle = $connectAsync.AsyncWaitHandle

            if (-not $waitHandle.WaitOne($this.TimeoutMs)) {
                $result.IsPortOpen = $false
                $result.ErrorMessage += " | Port $（$this.TargetPort） Connection Timeout"
            } else {
                $tcpClient.EndConnect($connectAsync)
                $result.IsPortOpen = $true
            }
        }
        catch [System.Exception] {
            $result.IsPingSuccess = $false
            $result.IsPortOpen    = $false
            $result.ErrorMessage  = $_.Exception.Message
        }
        finally {
            if ($null -ne $ping) { $ping.Dispose() }
            if ($null -ne $tcpClient) { $tcpClient.Dispose() }
        }

        return $result
    }
}

# -----------------------------------------------------------------------------


# 2. 実行制御クラス（Runspaceを用いた並列スレッドプールの管理）


# -----------------------------------------------------------------------------

class NodeMonitoringEngine {
    [NetworkNode[]]$Nodes

    NodeMonitoringEngine([NetworkNode[]]$nodes) {
        $this.Nodes = $nodes
    }

    [System.Collections.Concurrent.ConcurrentBag[MonitorResult]] ExecuteParallel() {
        $results = [System.Collections.Concurrent.ConcurrentBag[MonitorResult]]::new()

        # PowerShell 7以降であれば ForEach-Object -Parallel が利用可能だが、


        # 本コードは 5.1/7 互換を保つため .NET ThreadPool / Runspaces を抽象化したバックグラウンドジョブで動作

        $jobs = foreach ($node in $this.Nodes) {
            [PSCustomObject]@{
                Node   = $node
                Thread = [System.Threading.Tasks.Task[MonitorResult]]::Run([Func[MonitorResult]]{
                    return $node.TestNode()
                })
            }
        }

        # スレッドの同期待機と結果収集

        foreach ($job in $jobs) {
            try {
                $taskResult = $job.Thread.GetAwaiter().GetResult()
                $results.Add($taskResult)
            }
            catch {
                Write-Error "Thread execution failure for node $($job.Node.ComputerName): $_"
            }
        }

        return $results
    }
}

# -----------------------------------------------------------------------------


# 3. エントリーポイント（メイン処理）


# -----------------------------------------------------------------------------

function Start-NodeMonitoring {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true)]
        [string[]]$ComputerNames,

        [Parameter(Mandatory = $false)]
        [int]$Port = 443,

        [Parameter(Mandatory = $false)]
        [int]$TimeoutMs = 1500
    )

    Write-Verbose "Initializing Network Target List..."
    $nodeObjects = [System.Collections.Generic.List[NetworkNode]]::new()

    foreach ($name in $ComputerNames) {
        try {
            $nodeObjects.Add([NetworkNode]::new($name, $Port, $TimeoutMs))
        }
        catch {
            Write-Warning "Failed to instantiate Node for $name : $_"
        }
    }

    Write-Host "Starting parallel network monitoring for $($nodeObjects.Count) nodes..." -ForegroundColor Cyan
    $engine = [NodeMonitoringEngine]::new($nodeObjects.ToArray())

    # 処理計測開始

    $elapsed = Measure-Command {
        global:MonitoringReport = $engine.ExecuteParallel()
    }

    Write-Host "Monitoring completed in $($elapsed.TotalSeconds.ToString('F2')) seconds." -ForegroundColor Green

    # JSONレポート生成

    $reportPath = Join-Path $env:TEMP "MonitoringReport_$(Get-Date -Format 'yyyyMMdd_HHmmss').json"
    $MonitoringReport | ConvertTo-Json -Depth 3 | Out-File $reportPath -Encoding utf8
    Write-Host "Detailed report exported to: $reportPath" -ForegroundColor Yellow

    # コンソール出力用に整形して返却

    return $MonitoringReport
}

# テストデータの作成 (100台のホストリストをエミュレート)

$testHosts = (1..100) | ForEach-Object { "192.168.1.$_" }

# 実行計測

$metrics = Measure-Command {
    $results = Start-NodeMonitoring -ComputerNames $testHosts -Port 80 -TimeoutMs 1000 -Verbose
}

Write-Host "Total Execution Time: $($metrics.TotalMilliseconds) ms"