function Test-NetworkConnectivity {
    <#
    .SYNOPSIS
    测试网络连接性：TCP 端口扫描、HTTP 探测、延迟测量
    .PARAMETER ComputerName
    目标主机名或 IP 地址，支持数组
    .PARAMETER Ports
    要测试的 TCP 端口列表
    .PARAMETER TimeoutMs
    连接超时时间（毫秒），默认 3000
    .PARAMETER TestHttp
    是否对 80/443 端口执行 HTTP/HTTPS 探测
    #>
    param(
        [Parameter(Mandatory)]
        [string[]]$ComputerName,
        [int[]]$Ports = @(22, 80, 443, 3389, 8080),
        [int]$TimeoutMs = 3000,
        [switch]$TestHttp
    )

    $results = @()

    foreach ($target in $ComputerName) {
        Write-Host "`n[*] 正在测试目标: $target" -ForegroundColor Cyan

        # ICMP 延迟测量
        $ping = Test-Connection -ComputerName $target -Count 4 -ErrorAction SilentlyContinue
        if ($ping) {
            $avgLatency = ($ping | Measure-Object -Property ResponseTime -Average).Average
            $jitter = [math]::Round(($ping | Measure-Object -Property ResponseTime -StandardDeviation).StandardDeviation, 2)
            $packetLoss = [math]::Round((1 - ($ping.Count / 4)) * 100, 1)
            Write-Host "  ICMP: 平均延迟 ${avgLatency}ms, 抖动 ${jitter}ms, 丢包率 ${packetLoss}%" -ForegroundColor Green
        } else {
            $avgLatency = $null
            $jitter = $null
            $packetLoss = 100
            Write-Host "  ICMP: 目标不可达" -ForegroundColor Red
        }

        # TCP 端口扫描
        foreach ($port in $Ports) {
            $tcpClient = New-Object System.Net.Sockets.TcpClient
            $stopwatch = [System.Diagnostics.Stopwatch]::StartNew()

            try {
                $asyncResult = $tcpClient.BeginConnect($target, $port, $null, $null)
                $waited = $asyncResult.AsyncWaitHandle.WaitOne($TimeoutMs, $false)

                if ($waited) {
                    $tcpClient.EndConnect($asyncResult)
                    $stopwatch.Stop()
                    $status = "Open"
                    $latencyMs = $stopwatch.ElapsedMilliseconds
                    $color = "Green"
                } else {
                    $stopwatch.Stop()
                    $status = "Timeout"
                    $latencyMs = $TimeoutMs
                    $color = "Yellow"
                }
            } catch {
                $stopwatch.Stop()
                $status = "Closed"
                $latencyMs = $stopwatch.ElapsedMilliseconds
                $color = "Red"
            } finally {
                $tcpClient.Close()
            }

            $httpInfo = $null
            if ($TestHttp -and $status -eq "Open" -and $port -in @(80, 443)) {
                $scheme = if ($port -eq 443) { "https" } else { "http" }
                try {
                    $response = Invoke-WebRequest -Uri "${scheme}://${target}" `
                        -UseBasicParsing -TimeoutSec 5 -ErrorAction Stop
                    $httpInfo = @{
                        StatusCode = $response.StatusCode
                        Server     = $response.Headers["Server"]
                    }
                } catch {
                    $httpInfo = @{ StatusCode = $_.Exception.Response.StatusCode.Value__ }
                }
            }

            $result = [PSCustomObject]@{
                Target      = $target
                Port        = $port
                Status      = $status
                LatencyMs   = $latencyMs
                ICMPaAvgMs  = $avgLatency
                ICMPJitter  = $jitter
                ICMPLossPct = $packetLoss
                HttpInfo    = $httpInfo
                Timestamp   = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
            }
            $results += $result

            $httpStr = if ($httpInfo) { " | HTTP $($httpInfo.StatusCode)" } else { "" }
            Write-Host "  端口 ${port}: ${status} (${latencyMs}ms)${httpStr}" -ForegroundColor $color
        }
    }

    return $results
}

# 执行示例：检测 Web 服务器的常见端口
Test-NetworkConnectivity -ComputerName "example.com" -Ports @(22, 80, 443, 8080) -TestHttp

function Test-DnsResolution {
    <#
    .SYNOPSIS
    执行全面的 DNS 诊断：解析追踪、缓存检查、区域传输测试
    .PARAMETER DomainName
    要诊断的域名
    .PARAMETER DnsServer
    指定 DNS 服务器（默认使用系统配置）
    .PARAMETER RecordTypes
    要查询的记录类型列表
    #>
    param(
        [Parameter(Mandatory)]
        [string]$DomainName,
        [string]$DnsServer,
        [string[]]$RecordTypes = @("A", "AAAA", "CNAME", "MX", "NS", "TXT", "SOA")
    )

    Write-Host "`n========== DNS 诊断报告 ==========" -ForegroundColor Cyan
    Write-Host "目标域名: $DomainName"
    Write-Host "诊断时间: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')"
    Write-Host "===================================`n"

    # 1. 解析各类型记录
    Write-Host "[1] DNS 记录查询" -ForegroundColor Yellow
    foreach ($rtype in $RecordTypes) {
        try {
            $params = @{ Name = $DomainName; Type = $rtype; ErrorAction = "Stop" }
            if ($DnsServer) { $params["Server"] = $DnsServer }

            $records = Resolve-DnsName @params
            foreach ($rec in $records) {
                $section = $rec.Section
                $ttl = if ($rec.TTL) { "$($rec.TTL)s" } else { "N/A" }
                $value = switch ($rtype) {
                    "A"    { $rec.IPAddress }
                    "AAAA" { $rec.IPAddress }
                    "MX"   { "$($rec.Preference) $($rec.NameExchange)" }
                    "NS"   { $rec.NameHost }
                    "TXT"  { $rec.Strings -join " " }
                    "SOA"  { "$($rec.PrimaryServer) Serial=$($rec.Serial)" }
                    "CNAME"{ $rec.NameHost }
                    default { $rec.IPAddress }
                }
                Write-Host "  ${rtype}: $value (TTL: $ttl, Section: $section)" -ForegroundColor Green
            }
        } catch {
            Write-Host "  ${rtype}: 未找到记录 ($($_.Exception.Message))" -ForegroundColor DarkGray
        }
    }

    # 2. DNS 解析计时
    Write-Host "`n[2] 解析性能测试" -ForegroundColor Yellow
    $timings = @()
    for ($i = 1; $i -le 5; $i++) {
        $sw = [System.Diagnostics.Stopwatch]::StartNew()
        try {
            $null = Resolve-DnsName -Name $DomainName -Type A -ErrorAction Stop
            $sw.Stop()
            $timings += $sw.ElapsedMilliseconds
            Write-Host "  第 ${i} 次: $($sw.ElapsedMilliseconds)ms" -ForegroundColor Green
        } catch {
            $sw.Stop()
            $timings += $sw.ElapsedMilliseconds
            Write-Host "  第 ${i} 次: 失败 ($($sw.ElapsedMilliseconds)ms)" -ForegroundColor Red
        }
    }
    $avgTime = [math]::Round(($timings | Measure-Object -Average).Average, 2)
    $maxTime = ($timings | Measure-Object -Maximum).Maximum
    Write-Host "  平均: ${avgTime}ms, 最大: ${maxTime}ms" -ForegroundColor Cyan

    # 3. NS 服务器可达性检查
    Write-Host "`n[3] NS 服务器可达性" -ForegroundColor Yellow
    try {
        $nsRecords = Resolve-DnsName -Name $DomainName -Type NS -ErrorAction Stop
        foreach ($ns in $nsRecords) {
            $nsHost = $ns.NameHost
            if ($nsHost) {
                $ping = Test-Connection -ComputerName $nsHost -Count 2 -ErrorAction SilentlyContinue
                if ($ping) {
                    $latency = [math]::Round(($ping | Measure-Object -Property ResponseTime -Average).Average, 2)
                    Write-Host "  ${nsHost}: 在线 (${latency}ms)" -ForegroundColor Green
                } else {
                    Write-Host "  ${nsHost}: 不可达" -ForegroundColor Red
                }
            }
        }
    } catch {
        Write-Host "  无法获取 NS 记录" -ForegroundColor Red
    }

    # 4. SOA 序列号检查（判断 DNS 是否同步）
    Write-Host "`n[4] SOA 序列号一致性" -ForegroundColor Yellow
    try {
        $soa = Resolve-DnsName -Name $DomainName -Type SOA -ErrorAction Stop | Select-Object -First 1
        Write-Host "  主服务器: $($soa.PrimaryServer)" -ForegroundColor Green
        Write-Host "  序列号: $($soa.Serial)" -ForegroundColor Green
        Write-Host "  刷新间隔: $($soa.Refresh)s" -ForegroundColor Green
        Write-Host "  重试间隔: $($soa.Retry)s" -ForegroundColor Green
        Write-Host "  过期时间: $($soa.Expire)s" -ForegroundColor Green
    } catch {
        Write-Host "  无法获取 SOA 记录" -ForegroundColor Red
    }

    Write-Host "`n========== 诊断完成 ==========`n"
}

# 执行示例：诊断 vichamp.com 的 DNS 配置
Test-DnsResolution -DomainName "vichamp.com"

function Invoke-NetworkHealthCheck {
    <#
    .SYNOPSIS
    一键网络健康检查：综合连通性、DNS、路由追踪，生成 HTML 报告
    .PARAMETER Target
    目标主机名或 IP 地址
    .PARAMETER OutputPath
    HTML 报告输出路径
    #>
    param(
        [Parameter(Mandatory)]
        [string]$Target,
        [string]$OutputPath = ".\NetworkReport_$(Get-Date -Format 'yyyyMMdd_HHmmss').html"
    )

    $reportTime = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $sections = @()

    # ---- 第一部分：ICMP 连通性 ----
    $icmpResults = @()
    $pings = Test-Connection -ComputerName $Target -Count 10 -ErrorAction SilentlyContinue
    if ($pings) {
        $stats = $pings | Measure-Object -Property ResponseTime -Average -Minimum -Maximum -StandardDeviation
        $icmpResults += "状态: 在线"
        $icmpResults += "平均延迟: $([math]::Round($stats.Average, 2))ms"
        $icmpResults += "最小延迟: $($stats.Minimum)ms"
        $icmpResults += "最大延迟: $($stats.Maximum)ms"
        $icmpResults += "抖动(Jitter): $([math]::Round($stats.StandardDeviation, 2))ms"
        $icmpResults += "丢包率: $([math]::Round((1 - ($pings.Count / 10)) * 100, 1))%"
    } else {
        $icmpResults += "状态: 目标不可达"
    }

    # ---- 第二部分：关键端口检测 ----
    $portResults = @()
    $criticalPorts = @{
        22   = "SSH"
        53   = "DNS"
        80   = "HTTP"
        443  = "HTTPS"
        3389 = "RDP"
    }
    foreach ($port in $criticalPorts.Keys) {
        $tcpClient = New-Object System.Net.Sockets.TcpClient
        try {
            $asyncResult = $tcpClient.BeginConnect($Target, $port, $null, $null)
            $waited = $asyncResult.AsyncWaitHandle.WaitOne(3000, $false)
            if ($waited) {
                $tcpClient.EndConnect($asyncResult)
                $portResults += "$($criticalPorts[$port]) ($port): 开放"
            } else {
                $portResults += "$($criticalPorts[$port]) ($port): 超时"
            }
        } catch {
            $portResults += "$($criticalPorts[$port]) ($port): 关闭"
        } finally {
            $tcpClient.Close()
        }
    }

    # ---- 第三部分：DNS 解析 ----
    $dnsResults = @()
    try {
        $dnsRecs = Resolve-DnsName -Name $Target -Type A -ErrorAction Stop
        foreach ($rec in $dnsRecs) {
            if ($rec.IPAddress) {
                $dnsResults += "$($rec.Name) -> $($rec.IPAddress) (TTL: $($rec.TTL)s)"
            }
        }
    } catch {
        $dnsResults += "解析失败: $($_.Exception.Message)"
    }

    # ---- 第四部分：路由追踪（简化版 MTR） ----
    $hopResults = @()
    for ($ttl = 1; $ttl -le 15; $ttl++) {
        $ping = Test-Connection -ComputerName $Target -Count 1 -TTL $ttl -ErrorAction SilentlyContinue
        if ($ping) {
            $hopIP = $ping.Address
            $hopLatency = $ping.ResponseTime
            $hopResults += "跳 ${ttl}: ${hopIP} (${hopLatency}ms)"
            if ($hopIP -eq $Target -or $hopIP -match $Target) { break }
        } else {
            $hopResults += "跳 ${ttl}: * * *"
        }
    }

    # ---- 生成 HTML 报告 ----
    $html = @"
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<title>网络诊断报告 - $Target</title>
<style>
body { font-family: 'Segoe UI', Arial, sans-serif; margin: 40px; background: #f5f5f5; }
h1 { color: #2c3e50; border-bottom: 3px solid #3498db; padding-bottom: 10px; }
h2 { color: #2980b9; margin-top: 30px; }
.container { background: white; padding: 30px; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); }
.section { margin: 20px 0; padding: 15px; background: #fafafa; border-left: 4px solid #3498db; }
.ok { color: #27ae60; }
.warn { color: #f39c12; }
.fail { color: #e74c3c; }
.timestamp { color: #7f8c8d; font-size: 0.9em; }
</style>
</head>
<body>
<div class="container">
<h1>网络诊断报告</h1>
<p class="timestamp">目标: $Target | 生成时间: $reportTime</p>

<h2>ICMP 连通性</h2>
<div class="section">
$($icmpResults | ForEach-Object { "<p>$_</p>" })
</div>

<h2>关键端口状态</h2>
<div class="section">
$($portResults | ForEach-Object {
    if ($_ -match "开放") { "<p class=`"ok`">$_</p>" }
    elseif ($_ -match "超时") { "<p class=`"warn`">$_</p>" }
    else { "<p class=`"fail`">$_</p>" }
})
</div>

<h2>DNS 解析</h2>
<div class="section">
$($dnsResults | ForEach-Object { "<p>$_</p>" })
</div>

<h2>路由追踪</h2>
<div class="section">
$($hopResults | ForEach-Object { "<p>$_</p>" })
</div>

</div>
</body>
</html>
"@

    $html | Out-File -FilePath $OutputPath -Encoding UTF8
    Write-Host "诊断报告已生成: $OutputPath" -ForegroundColor Green

    # 同时输出控制台摘要
    Write-Host "`n===== 网络健康检查摘要 =====" -ForegroundColor Cyan
    Write-Host "目标: $Target"
    $icmpResults | ForEach-Object { Write-Host "  $_" }
    Write-Host "`n端口状态:" -ForegroundColor Yellow
    $portResults | ForEach-Object { Write-Host "  $_" }
    Write-Host "`n路由路径:" -ForegroundColor Yellow
    $hopResults | ForEach-Object { Write-Host "  $_" }
    Write-Host "============================`n"
}

# 执行示例：一键检查并生成 HTML 报告
Invoke-NetworkHealthCheck -Target "blog.vichamp.com"

function Get-NetworkInterfaceHealth {
    <#
    .SYNOPSIS
    获取本机所有活跃网络接口的健康状态
    #>

    $adapters = Get-NetAdapter |
        Where-Object { $_.Status -eq 'Up' -and $_.InterfaceType -notmatch 'Loopback' }

    $results = foreach ($adapter in $adapters) {
        $ipConfig = Get-NetIPAddress -InterfaceIndex $adapter.ifIndex -AddressFamily IPv2 -ErrorAction SilentlyContinue |
            Select-Object -First 1

        $stats = Get-NetAdapterStatistics -Name $adapter.Name -ErrorAction SilentlyContinue

        [PSCustomObject]@{
            名称       = $adapter.Name
            接口描述   = $adapter.InterfaceDescription
            链路速率   = "$($adapter.LinkSpeed)"
            IPv4地址   = if ($ipConfig) { $ipConfig.IPAddress } else { '未分配' }
            已接收字节 = if ($stats) { '{0:N2} GB' -f ($stats.ReceivedBytes / 1GB) } else { 'N/A' }
            已发送字节 = if ($stats) { '{0:N2} GB' -f ($stats.SentBytes / 1GB) } else { 'N/A' }
            MAC地址    = $adapter.MacAddress
        }
    }

    $results | Format-Table -AutoSize
    $results
}

Get-NetworkInterfaceHealth

function Test-HttpQuality {
    <#
    .SYNOPSIS
    测试 HTTP/HTTPS 服务的响应质量
    #>
    param(
        [Parameter(Mandatory)]
        [string[]]$Urls,

        [int]$TimeoutSec = 10
    )

    $results = foreach ($url in $Urls) {
        $timer = [System.Diagnostics.Stopwatch]::StartNew()

        try {
            $response = Invoke-WebRequest -Uri $url -TimeoutSec $TimeoutSec `
                -UseBasicParsing -MaximumRedirection 0 -ErrorAction Stop

            $timer.Stop()

            [PSCustomObject]@{
                URL       = $url
                状态码    = [int]$response.StatusCode
                状态描述  = $response.StatusDescription
                总耗时ms  = $timer.ElapsedMilliseconds
                内容长度  = if ($response.Headers['Content-Length']) {
                    '{0:N0} bytes' -f [int]$response.Headers['Content-Length']
                } else {
                    'N/A'
                }
                服务器    = if ($response.Headers['Server']) {
                    $response.Headers['Server']
                } else {
                    '-'
                }
                结果      = '成功'
            }
        } catch {
            $timer.Stop()
            $statusCode = $null

            if ($_.Exception.Response) {
                $statusCode = [int]$_.Exception.Response.StatusCode
            }

            [PSCustomObject]@{
                URL       = $url
                状态码    = $statusCode
                状态描述  = if ($statusCode) { $_.Exception.Message.Substring(0, 60) } else { '-' }
                总耗时ms  = $timer.ElapsedMilliseconds
                内容长度  = 'N/A'
                服务器    = '-'
                结果      = '失败'
            }
        }
    }

    $results | Format-Table -AutoSize
}

$targets = @(
    'https://blog.vichamp.com',
    'https://github.com',
    'https://nonexistent-test-12345.example.com'
)

Test-HttpQuality -Urls $targets

function Test-NetworkLatency {
    <#
    .SYNOPSIS
    测试到目标主机的延迟和丢包率
    #>
    param(
        [Parameter(Mandatory)]
        [string[]]$Targets,

        [int]$Count = 20,

        [int]$DelayMs = 500
    )

    $results = foreach ($target in $Targets) {
        Write-Host "正在测试 $target ..." -ForegroundColor Gray

        $latencies = [System.Collections.Generic.List[double]]::new()
        $lostCount = 0

        for ($i = 0; $i -lt $Count; $i++) {
            $reply = Test-Connection -ComputerName $target -Count 1 -Quiet -ErrorAction SilentlyContinue

            if ($reply) {
                $detail = Test-Connection -ComputerName $target -Count 1 -ErrorAction SilentlyContinue
                if ($detail) {
                    $latencies.Add($detail.ResponseTime)
                }
            } else {
                $lostCount++
            }

            if ($i -lt $Count - 1) {
                Start-Sleep -Milliseconds $DelayMs
            }
        }

        if ($latencies.Count -gt 0) {
            $avg = [math]::Round(($latencies | Measure-Object -Average).Average, 1)
            $min = [math]::Round(($latencies | Measure-Object -Minimum).Minimum, 1)
            $max = [math]::Round(($latencies | Measure-Object -Maximum).Maximum, 1)

            # 计算抖动（相邻延迟差的平均值）
            $jitterValues = [System.Collections.Generic.List[double]]::new()
            for ($j = 1; $j -lt $latencies.Count; $j++) {
                $jitterValues.Add([math]::Abs($latencies[$j] - $latencies[$j - 1]))
            }
            $jitter = if ($jitterValues.Count -gt 0) {
                [math]::Round(($jitterValues | Measure-Object -Average).Average, 1)
            } else {
                0
            }

            $lossRate = [math]::Round(($lostCount / $Count) * 100, 1)

            # 综合评级
            $grade = if ($avg -lt 10 -and $lossRate -eq 0 -and $jitter -lt 5) {
                '优秀'
            } elseif ($avg -lt 50 -and $lossRate -lt 1) {
                '良好'
            } elseif ($avg -lt 100 -and $lossRate -lt 5) {
                '一般'
            } else {
                '较差'
            }
        } else {
            $avg = $min = $max = $jitter = 0
            $lossRate = 100
            $grade = '不可达'
        }

        [PSCustomObject]@{
            目标   = $target
            平均ms = $avg
            最小ms = $min
            最大ms = $max
            抖动ms = $jitter
            丢包率 = "$lossRate%"
            评级   = $grade
        }
    }

    $results | Format-Table -AutoSize
}

# 批量测试多个目标的网络质量
Test-NetworkLatency -Targets @(
    'baidu.com',
    'google.com',
    'github.com'
) -Count 15

function Watch-NetworkTraffic {
    <#
    .SYNOPSIS
    实时监控网络接口流量
    #>
    param(
        [string]$InterfaceName = (Get-NetAdapter |
            Where-Object { $_.Status -eq 'Up' -and $_.InterfaceType -notmatch 'Loopback' } |
            Select-Object -First 1).Name,

        [int]$DurationSeconds = 30,

        [int]$IntervalSeconds = 2
    )

    $adapter = Get-NetAdapter -Name $InterfaceName -ErrorAction SilentlyContinue

    if (-not $adapter) {
        Write-Host "未找到网络接口：$InterfaceName" -ForegroundColor Red
        return
    }

    Write-Host "监控接口：$InterfaceName ($($adapter.InterfaceDescription))" -ForegroundColor Cyan
    Write-Host "持续时间：${DurationSeconds}秒，采样间隔：${IntervalSeconds}秒" -ForegroundColor Cyan
    Write-Host ('-' * 70)

    $samples = [System.Collections.Generic.List[PSCustomObject]]::new()
    $startTime = Get-Date

    $prevStats = Get-NetAdapterStatistics -Name $InterfaceName
    $prevTime = Get-Date

    while (((Get-Date) - $startTime).TotalSeconds -lt $DurationSeconds) {
        Start-Sleep -Seconds $IntervalSeconds

        $currentStats = Get-NetAdapterStatistics -Name $InterfaceName
        $currentTime = Get-Date

        $elapsed = ($currentTime - $prevTime).TotalSeconds
        if ($elapsed -le 0) { $elapsed = 1 }

        $rxRate = ($currentStats.ReceivedBytes - $prevStats.ReceivedBytes) / $elapsed
        $txRate = ($currentStats.SentBytes - $prevStats.SentBytes) / $elapsed

        function Format-Bytes {
            param([double]$Bytes)
            if ($Bytes -ge 1MB) { '{0,8:N2} MB/s' -f ($Bytes / 1MB) }
            elseif ($Bytes -ge 1KB) { '{0,8:N2} KB/s' -f ($Bytes / 1KB) }
            else { '{0,8:N2}  B/s' -f $Bytes }
        }

        $sample = [PSCustomObject]@{
            时间     = $currentTime.ToString('HH:mm:ss')
            接收速率 = Format-Bytes $rxRate
            发送速率 = Format-Bytes $txRate
            累计接收 = '{0:N2} MB' -f ($currentStats.ReceivedBytes / 1MB)
            累计发送 = '{0:N2} MB' -f ($currentStats.SentBytes / 1MB)
        }

        $samples.Add($sample)
        Write-Host ("  {0}  |  接收: {1}  |  发送: {2}" -f `
            $sample.时间, $sample.接收速率, $sample.发送速率)

        $prevStats = $currentStats
        $prevTime = $currentTime
    }

    Write-Host ('-' * 70)
    Write-Host "采样完成，共 $($samples.Count) 个数据点" -ForegroundColor Green

    $samples | Format-Table -AutoSize
}

# 监控 30 秒内的网络流量变化
Watch-NetworkTraffic -DurationSeconds 30 -IntervalSeconds 3

# 基本 TCP 连接
function Send-TcpMessage {
    param(
        [Parameter(Mandatory)]
        [string]$Server,

        [Parameter(Mandatory)]
        [int]$Port,

        [string]$Message,

        [int]$TimeoutMs = 5000
    )

    $client = [System.Net.Sockets.TcpClient]::new()
    try {
        $connectTask = $client.ConnectAsync($Server, $Port)
        $connectTask.Wait($TimeoutMs) | Out-Null

        if (-not $client.Connected) {
            throw "连接超时"
        }

        $stream = $client.GetStream()
        $writer = [System.IO.StreamWriter]::new($stream)
        $reader = [System.IO.StreamReader]::new($stream)
        $writer.AutoFlush = $true

        if ($Message) {
            $writer.WriteLine($Message)
        }

        Start-Sleep -Milliseconds 500

        if ($stream.DataAvailable) {
            $response = $reader.ReadToEnd()
            return $response
        }
    } finally {
        $client.Close()
    }
}

# 测试 TCP 端口连通性
function Test-TcpPort {
    param(
        [Parameter(Mandatory)]
        [string]$ComputerName,

        [Parameter(Mandatory)]
        [int]$Port,

        [int]$TimeoutMs = 3000
    )

    $client = [System.Net.Sockets.TcpClient]::new()
    $sw = [System.Diagnostics.Stopwatch]::StartNew()

    try {
        $connectTask = $client.ConnectAsync($ComputerName, $Port)
        $connectTask.Wait($TimeoutMs) | Out-Null

        $sw.Stop()
        $success = $client.Connected

        return [PSCustomObject]@{
            Computer  = $ComputerName
            Port      = $Port
            IsOpen    = $success
            LatencyMs = $sw.ElapsedMilliseconds
        }
    } catch {
        $sw.Stop()
        return [PSCustomObject]@{
            Computer  = $ComputerName
            Port      = $Port
            IsOpen    = $false
            LatencyMs = $sw.ElapsedMilliseconds
        }
    } finally {
        $client.Close()
    }
}

# 批量端口扫描
$targets = @(
    @{ Host = "google.com"; Ports = @(80, 443, 8080) },
    @{ Host = "github.com"; Ports = @(22, 80, 443) }
)

foreach ($target in $targets) {
    Write-Host "$($target.Host)：" -ForegroundColor Cyan
    foreach ($port in $target.Ports) {
        $result = Test-TcpPort -ComputerName $target.Host -Port $port
        $status = if ($result.IsOpen) { "OPEN" } else { "CLOSED" }
        $color = if ($result.IsOpen) { "Green" } else { "Red" }
        Write-Host "  Port $($result.Port) : $status ($($result.LatencyMs)ms)" -ForegroundColor $color
    }
}

# UDP 客户端
function Send-UdpMessage {
    param(
        [Parameter(Mandatory)]
        [string]$Server,

        [Parameter(Mandatory)]
        [int]$Port,

        [Parameter(Mandatory)]
        [string]$Message,

        [int]$TimeoutMs = 3000
    )

    $client = [System.Net.Sockets.UdpClient]::new()
    try {
        $client.Connect($Server, $Port)
        $bytes = [System.Text.Encoding]::UTF8.GetBytes($Message)
        $client.Send($bytes, $bytes.Length) | Out-Null

        # 等待响应（UDP 不保证有响应）
        $client.Client.ReceiveTimeout = $TimeoutMs
        $remoteEP = [System.Net.IPEndPoint]::new([System.Net.IPAddress]::Any, 0)
        $response = $client.Receive([ref]$remoteEP)

        return [System.Text.Encoding]::UTF8.GetString($response)
    } catch {
        return $null
    } finally {
        $client.Close()
    }
}

# DNS 查询示例（使用 System.Net）
function Resolve-DnsFast {
    param([Parameter(Mandatory)][string]$Hostname)

    try {
        $addresses = [System.Net.Dns]::GetHostAddresses($Hostname)
        foreach ($addr in $addresses) {
            [PSCustomObject]@{
                Hostname = $Hostname
                Address  = $addr.ToString()
                Family   = $addr.AddressFamily
            }
        }
    } catch {
        Write-Host "解析失败：$Hostname" -ForegroundColor Red
    }
}

Resolve-DnsFast -Hostname "www.microsoft.com" | Format-Table -AutoSize

# 服务端口监控
function Test-ServicePorts {
    param(
        [PSCustomObject[]]$Services = @(
            @{ Name = "Web"; Host = "localhost"; Port = 80 },
            @{ Name = "HTTPS"; Host = "localhost"; Port = 443 },
            @{ Name = "SSH"; Host = "localhost"; Port = 22 },
            @{ Name = "MySQL"; Host = "localhost"; Port = 3306 },
            @{ Name = "Redis"; Host = "localhost"; Port = 6379 }
        )
    )

    $results = foreach ($svc in $Services) {
        $test = Test-TcpPort -ComputerName $svc.Host -Port $svc.Port -TimeoutMs 2000
        [PSCustomObject]@{
            Service = $svc.Name
            Host    = $svc.Host
            Port    = $svc.Port
            Status  = if ($test.IsOpen) { "Listening" } else { "Closed" }
            Latency = "$($test.LatencyMs)ms"
        }
    }

    $results | Format-Table -AutoSize

    $closed = $results | Where-Object { $_.Status -eq "Closed" }
    if ($closed) {
        Write-Host "告警：$($closed.Count) 个端口未监听" -ForegroundColor Red
        $closed | ForEach-Object {
            Write-Host "  $($_.Service) ($($_.Host):$($_.Port))" -ForegroundColor Red
        }
    }
}

Test-ServicePorts

# SMTP 协议探测
function Test-SmtpServer {
    param(
        [Parameter(Mandatory)]
        [string]$Server,

        [int]$Port = 25,

        [int]$TimeoutMs = 10000
    )

    $client = [System.Net.Sockets.TcpClient]::new()
    try {
        $client.Connect($Server, $Port)
        $stream = $client.GetStream()
        $reader = [System.IO.StreamReader]::new($stream)
        $writer = [System.IO.StreamWriter]::new($stream)
        $writer.AutoFlush = $true

        $client.Client.ReceiveTimeout = $TimeoutMs

        # 读取欢迎信息
        $banner = $reader.ReadLine()
        Write-Host "SMTP Banner：$banner" -ForegroundColor Cyan

        # 发送 EHLO
        $writer.WriteLine("EHLO test.local")
        Start-Sleep -Milliseconds 500
        while ($stream.DataAvailable) {
            $line = $reader.ReadLine()
            Write-Host "  $line" -ForegroundColor DarkGray
        }

        # 发送 QUIT
        $writer.WriteLine("QUIT")
        $bye = $reader.ReadLine()
        Write-Host "  $bye" -ForegroundColor DarkGray

        return $true
    } catch {
        Write-Host "SMTP 连接失败：$($_.Exception.Message)" -ForegroundColor Red
        return $false
    } finally {
        $client.Close()
    }
}

Test-SmtpServer -Server "mail.contoso.com" -Port 25

# 本地端口转发：将远程数据库映射到本地端口
# 场景：远程 MySQL 在 10.0.1.50:3306，通过跳板机 bastion.example.com 访问

function New-SSHTunnel {
    param(
        [Parameter(Mandatory)]
        [string]$JumpHost,

        [Parameter(Mandatory)]
        [int]$LocalPort,

        [Parameter(Mandatory)]
        [string]$RemoteHost,

        [Parameter(Mandatory)]
        [int]$RemotePort,

        [string]$SshUser = $env:USERNAME,

        [string]$KeyPath
    )

    $sshArgs = @(
        "-N"              # 不执行远程命令
        "-L"              # 本地端口转发
        "${LocalPort}:${RemoteHost}:${RemotePort}"
    )

    if ($KeyPath) {
        $sshArgs += "-i", $KeyPath
    }

    $sshArgs += "${SshUser}@${JumpHost}"

    # 启动 SSH 进程（后台运行）
    $process = Start-Process -FilePath "ssh" `
        -ArgumentList $sshArgs `
        -WindowStyle Hidden `
        -PassThru

    # 等待端口就绪
    $ready = $false
    for ($i = 0; $i -lt 10; $i++) {
        Start-Sleep -Milliseconds 500
        try {
            $tcp = New-Object System.Net.Sockets.TcpClient("127.0.0.1", $LocalPort)
            $tcp.Close()
            $ready = $true
            break
        } catch {
            # 端口尚未就绪，继续等待
        }
    }

    if ($ready) {
        Write-Host "SSH 隧道已建立：localhost:${LocalPort} -> ${RemoteHost}:${RemotePort}" `
            -ForegroundColor Green
        Write-Host "进程 ID：$($process.Id)"
    } else {
        Write-Warning "隧道建立超时，请检查连接参数"
    }

    return $process
}

# 示例：通过跳板机连接远程 MySQL
$tunnel = New-SSHTunnel -JumpHost "bastion.example.com" `
    -LocalPort 13306 `
    -RemoteHost "10.0.1.50" `
    -RemotePort 3306 `
    -SshUser "admin" `
    -KeyPath "$env:USERPROFILE\.ssh\id_rsa"

# 远程端口转发：将本地服务暴露给远程网络
# 场景：让远程服务器访问本地开发中的 Web API

function New-SSHRemoteTunnel {
    param(
        [Parameter(Mandatory)]
        [string]$RemoteServer,

        [Parameter(Mandatory)]
        [int]$RemotePort,

        [Parameter(Mandatory)]
        [string]$LocalHost,

        [Parameter(Mandatory)]
        [int]$LocalPort,

        [string]$SshUser = $env:USERNAME
    )

    $sshArgs = @(
        "-N"
        "-R"
        "${RemotePort}:${LocalHost}:${LocalPort}"
        "${SshUser}@${RemoteServer}"
    )

    $process = Start-Process -FilePath "ssh" `
        -ArgumentList $sshArgs `
        -WindowStyle Hidden `
        -PassThru

    Write-Host "远程隧道已建立：${RemoteServer}:${RemotePort} -> ${LocalHost}:${LocalPort}" `
        -ForegroundColor Green
    return $process
}

# 动态端口转发（SOCKS 代理）
function New-SSHSocksProxy {
    param(
        [Parameter(Mandatory)]
        [string]$Server,

        [int]$LocalPort = 1080,

        [string]$SshUser = $env:USERNAME,

        [string]$KeyPath
    )

    $sshArgs = @(
        "-N"
        "-D"               # 动态转发，创建 SOCKS5 代理
        "$LocalPort"
    )

    if ($KeyPath) {
        $sshArgs += "-i", $KeyPath
    }

    $sshArgs += "${SshUser}@${Server}"

    $process = Start-Process -FilePath "ssh" `
        -ArgumentList $sshArgs `
        -WindowStyle Hidden `
        -PassThru

    Write-Host "SOCKS5 代理已启动：127.0.0.1:${LocalPort}" -ForegroundColor Green
    Write-Host "使用方式：配置浏览器或工具使用 SOCKS5 代理 127.0.0.1:${LocalPort}"
    return $process
}

# 示例：创建 SOCKS5 代理
$socks = New-SSHSocksProxy -Server "bastion.example.com" `
    -LocalPort 1080 `
    -SshUser "admin"

# 隧道管理器：统一管理多个 SSH 隧道
$script:TunnelRegistry = @{}

function Register-Tunnel {
    param(
        [Parameter(Mandatory)][string]$Name,
        [Parameter(Mandatory)][System.Diagnostics.Process]$Process,
        [int]$LocalPort,
        [string]$Target
    )

    $script:TunnelRegistry[$Name] = @{
        Process   = $Process
        LocalPort = $LocalPort
        Target    = $Target
        CreatedAt = Get-Date
        Status    = "Running"
    }
}

function Get-SSHTunnel {
    param([string]$Name)

    if ($Name) {
        $entry = $script:TunnelRegistry[$Name]
        if ($entry) {
            # 检查进程是否仍在运行
            $alive = Get-Process -Id $entry.Process.Id -ErrorAction SilentlyContinue
            $status = if ($alive) { "Running" } else { "Stopped" }
            $entry.Status = $status

            [PSCustomObject]@{
                Name      = $Name
                PID       = $entry.Process.Id
                LocalPort = $entry.LocalPort
                Target    = $entry.Target
                Status    = $status
                Uptime    = (Get-Date) - $entry.CreatedAt
            }
        }
    } else {
        foreach ($key in $script:TunnelRegistry.Keys) {
            Get-SSHTunnel -Name $key
        }
    }
}

function Stop-SSHTunnel {
    param([Parameter(Mandatory)][string]$Name)

    $entry = $script:TunnelRegistry[$Name]
    if (-not $entry) {
        Write-Warning "未找到隧道：$Name"
        return
    }

    $process = $entry.Process
    if ($process -and -not $process.HasExited) {
        Stop-Process -Id $process.Id -Force
        Write-Host "隧道 '$Name' 已停止（PID: $($process.Id)）" -ForegroundColor Yellow
    }

    $script:TunnelRegistry.Remove($Name)
}

# 使用示例
$tunnel1 = New-SSHTunnel -JumpHost "bastion.example.com" `
    -LocalPort 13306 -RemoteHost "10.0.1.50" -RemotePort 3306 -SshUser "admin"
Register-Tunnel -Name "mysql-prod" -Process $tunnel1 -LocalPort 13306 -Target "10.0.1.50:3306"

$tunnel2 = New-SSHTunnel -JumpHost "bastion.example.com" `
    -LocalPort 15432 -RemoteHost "10.0.1.60" -RemotePort 5432 -SshUser "admin"
Register-Tunnel -Name "pg-prod" -Process $tunnel2 -LocalPort 15432 -Target "10.0.1.60:5432"

# 查看所有隧道状态
Get-SSHTunnel | Format-Table -AutoSize

# 隧道守护进程：自动检测断线并重连
function Start-TunnelDaemon {
    param(
        [int]$CheckIntervalSeconds = 30
    )

    Write-Host "隧道守护进程已启动，检查间隔：${CheckIntervalSeconds}秒" -ForegroundColor Cyan

    while ($true) {
        $tunnels = Get-SSHTunnel
        foreach ($t in $tunnels) {
            if ($t.Status -ne "Running") {
                Write-Warning "检测到隧道 '$($t.Name)' 已断开，尝试重连..."

                # 尝试检测端口是否仍被占用（残留进程）
                $portInUse = Get-NetTCPConnection -LocalPort $t.LocalPort `
                    -ErrorAction SilentlyContinue

                if ($portInUse) {
                    Write-Host "端口 $($t.LocalPort) 仍被占用，等待释放..." -ForegroundColor Yellow
                    continue
                }

                # 解析目标地址
                $parts = $t.Target -split ":"
                $remoteHost = $parts[0]
                $remotePort = [int]$parts[1]

                # 重新建立隧道
                $newTunnel = New-SSHTunnel -JumpHost "bastion.example.com" `
                    -LocalPort $t.LocalPort `
                    -RemoteHost $remoteHost `
                    -RemotePort $remotePort `
                    -SshUser "admin"

                if ($newTunnel) {
                    Register-Tunnel -Name $t.Name -Process $newTunnel `
                        -LocalPort $t.LocalPort -Target $t.Target
                    Write-Host "隧道 '$($t.Name)' 重连成功" -ForegroundColor Green
                }
            }
        }

        Start-Sleep -Seconds $CheckIntervalSeconds
    }
}

# 端口连通性测试工具
function Test-TunnelConnectivity {
    param(
        [Parameter(Mandatory)]
        [string]$HostName,

        [Parameter(Mandatory)]
        [int]$Port,

        [int]$TimeoutMs = 3000
    )

    $tcp = New-Object System.Net.Sockets.TcpClient
    $asyncResult = $tcp.BeginConnect($HostName, $Port, $null, $null)
    $waited = $asyncResult.AsyncWaitHandle.WaitOne($TimeoutMs, $false)

    $result = if ($waited -and $tcp.Connected) {
        $tcp.EndConnect($asyncResult)
        [PSCustomObject]@{
            Host   = $HostName
            Port   = $Port
            Status = "Open"
            Latency = "N/A"
        }
    } else {
        [PSCustomObject]@{
            Host   = $HostName
            Port   = $Port
            Status = "Closed"
            Latency = "N/A"
        }
    }

    $tcp.Close()
    return $result
}

# 批量检查所有隧道
Get-SSHTunnel | ForEach-Object {
    Test-TunnelConnectivity -HostName "127.0.0.1" -Port $_.LocalPort
} | Format-Table -AutoSize