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"

# 基本 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

# Test-Connection（PowerShell 的 ping）
Test-Connection -ComputerName google.com -Count 4 |
    Select-Object Address, @{N='延迟ms'; E={$_.ResponseTime}}, Status |
    Format-Table -AutoSize

# Test-NetConnection（更强大的网络测试）
Test-NetConnection -ComputerName blog.vichamp.com -Port 443 |
    Select-Object ComputerName, RemoteAddress, RemotePort, TcpTestSucceeded, PingSucceeded |
    Format-List

# 批量测试多台服务器的连通性
$servers = @('web-01.internal', 'db-01.internal', 'api-01.internal', 'redis-01.internal')

$results = foreach ($server in $servers) {
    $test = Test-NetConnection -ComputerName $server -WarningAction SilentlyContinue
    [PSCustomObject]@{
        Server  = $server
        IP      = $test.RemoteAddress
        Ping    = $test.PingSucceeded
        Port    = if ($test.TcpTestSucceeded) { 'Open' } else { 'Closed/Filtered' }
    }
}

$results | Format-Table -AutoSize

# DNS 解析
Resolve-DnsName -Name blog.vichamp.com | Format-Table -AutoSize

# 查看所有 DNS 记录类型
Resolve-DnsName -Name contoso.com -Type ANY |
    Select-Object Name, Type, Section, Data |
    Format-Table -AutoSize

# 查看当前 DNS 服务器配置
Get-DnsClientServerAddress -AddressFamily IPv4 |
    Where-Object { $_.InterfaceAlias -notmatch 'Loopback' } |
    Select-Object InterfaceAlias, ServerAddresses |
    Format-Table -AutoSize

# 刷新 DNS 缓存
Clear-DnsClientCache
Write-Host "DNS 缓存已清除" -ForegroundColor Green

# DNS 解析对比（用不同 DNS 服务器）
function Compare-DnsResolution {
    param([string]$Domain)

    $servers = @{
        '默认'   = $null
        'Google' = '8.8.8.8'
        'Cloudflare' = '1.1.1.1'
        'AliDNS' = '223.5.5.5'
    }

    foreach ($name in $servers.Keys) {
        try {
            $params = @{ Name = $Domain }
            if ($servers[$name]) { $params.Server = $servers[$name] }

            $result = Resolve-DnsName @params -ErrorAction Stop |
                Select-Object -First 1

            [PSCustomObject]@{
                DNS服务器 = $name
                IP地址    = $result.IPAddress
                类型      = $result.Type
                TTL       = $result.TTL
            }
        } catch {
            [PSCustomObject]@{
                DNS服务器 = $name
                IP地址    = "解析失败: $($_.Exception.Message)"
            }
        }
    }
}

Compare-DnsResolution -Domain "blog.vichamp.com" | Format-Table -AutoSize

function Test-TcpPort {
    <#
    .SYNOPSIS
    测试目标主机的 TCP 端口连通性
    #>
    param(
        [Parameter(Mandatory)]
        [string]$ComputerName,

        [int[]]$Ports = @(22, 80, 443, 3389, 5985, 5986, 8080, 1433, 3306, 6379),

        [int]$TimeoutMs = 3000
    )

    $results = foreach ($port in $Ports) {
        $tcpClient = New-Object System.Net.Sockets.TcpClient
        $asyncResult = $tcpClient.BeginConnect($ComputerName, $port, $null, $null)
        $waited = $asyncResult.AsyncWaitHandle.WaitOne($TimeoutMs, $false)

        $isOpen = $false
        if ($waited) {
            try {
                $tcpClient.EndConnect($asyncResult)
                $isOpen = $true
            } catch {
                $isOpen = $false
            }
        }

        $tcpClient.Close()

        $serviceName = switch ($port) {
            22    { 'SSH' }
            80    { 'HTTP' }
            443   { 'HTTPS' }
            3389  { 'RDP' }
            5985  { 'WinRM-HTTP' }
            5986  { 'WinRM-HTTPS' }
            8080  { 'HTTP-Alt' }
            1433  { 'MSSQL' }
            3306  { 'MySQL' }
            6379  { 'Redis' }
            default { 'Unknown' }
        }

        [PSCustomObject]@{
            Port   = $port
            Service = $serviceName
            Status = if ($isOpen) { 'Open' } else { 'Closed' }
        }
    }

    $results | Format-Table -AutoSize
}

# 扫描目标服务器的常用端口
Test-TcpPort -ComputerName "192.168.1.100" -Ports @(22, 80, 443, 3389, 5985, 1433, 6379)

function Invoke-NetworkTroubleshooter {
    <#
    .SYNOPSIS
    一键式网络排障脚本
    #>
    param(
        [Parameter(Mandatory)]
        [string]$Target,

        [int]$Port = 443
    )

    Write-Host "========== 网络排障：$Target ==========" -ForegroundColor Cyan

    # Step 1: DNS 解析
    Write-Host "`n[1/5] DNS 解析" -ForegroundColor Yellow
    try {
        $dns = Resolve-DnsName -Name $Target -ErrorAction Stop
        $ip = ($dns | Where-Object { $_.Type -eq 'A' } | Select-Object -First 1).IPAddress
        if (-not $ip) {
            $ip = ($dns | Select-Object -First 1).IPAddress
        }
        Write-Host "  解析结果：$Target => $ip" -ForegroundColor Green
    } catch {
        Write-Host "  DNS 解析失败：$($_.Exception.Message)" -ForegroundColor Red
        Write-Host "  建议：检查 DNS 配置或尝试使用其他 DNS 服务器" -ForegroundColor Yellow
        return
    }

    # Step 2: ICMP Ping
    Write-Host "`n[2/5] Ping 测试" -ForegroundColor Yellow
    $ping = Test-Connection -ComputerName $ip -Count 3 -Quiet
    if ($ping) {
        $latency = (Test-Connection -ComputerName $ip -Count 1).ResponseTime
        Write-Host "  Ping 成功，延迟：${latency}ms" -ForegroundColor Green
    } else {
        Write-Host "  Ping 失败（可能被防火墙阻止）" -ForegroundColor Yellow
    }

    # Step 3: TCP 端口测试
    Write-Host "`n[3/5] TCP 端口测试 ($Port)" -ForegroundColor Yellow
    $tcp = Test-NetConnection -ComputerName $ip -Port $Port -WarningAction SilentlyContinue
    if ($tcp.TcpTestSucceeded) {
        Write-Host "  端口 $Port 连接成功" -ForegroundColor Green
    } else {
        Write-Host "  端口 $Port 连接失败" -ForegroundColor Red
        Write-Host "  建议：检查防火墙规则或目标服务是否运行" -ForegroundColor Yellow
    }

    # Step 4: 路由追踪
    Write-Host "`n[4/5] 路由追踪 (tracert)" -ForegroundColor Yellow
    $trace = tracert -d -h 15 -w 1000 $ip 2>$null
    $trace | Select-Object -First 15 | ForEach-Object { Write-Host "  $_" }

    # Step 5: HTTP 测试（如果是 Web 服务）
    if ($Port -in @(80, 443, 8080, 8443)) {
        Write-Host "`n[5/5] HTTP 测试" -ForegroundColor Yellow
        $protocol = if ($Port -in @(443, 8443)) { 'https' } else { 'http' }
        try {
            $response = Invoke-WebRequest -Uri "${protocol}://${Target}" `
                -TimeoutSec 10 -UseBasicParsing -MaximumRedirection 0 -ErrorAction Stop
            Write-Host "  HTTP $($response.StatusCode) - $($response.StatusDescription)" -ForegroundColor Green
        } catch {
            $statusCode = $_.Exception.Response.StatusCode
            if ($statusCode) {
                Write-Host "  HTTP $([int]$statusCode) - $($statusCode)" -ForegroundColor Yellow
            } else {
                Write-Host "  HTTP 请求失败：$($_.Exception.Message)" -ForegroundColor Red
            }
        }
    }

    Write-Host "`n========== 排障完成 ==========" -ForegroundColor Cyan
}

# 一键排查网络问题
Invoke-NetworkTroubleshooter -Target "blog.vichamp.com" -Port 443