function Get-PlatformInfo {
    [CmdletBinding()]
    param()

    $result = [ordered]@{
        Platform     = 'Unknown'
        IsWindows    = $false
        IsLinux      = $false
        IsMacOS      = $false
        Architecture = [System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture.ToString()
        OSVersion    = ''
        ShellName    = $PSVersionTable.ShellId
        PSVersion    = $PSVersionTable.PSVersion.ToString()
    }

    if ($IsWindows) {
        $result.Platform  = 'Windows'
        $result.IsWindows = $true
        $result.OSVersion = [System.Environment]::OSVersion.VersionString
    }
    elseif ($IsLinux) {
        $result.Platform = 'Linux'
        $result.IsLinux  = $true
        if (Test-Path /etc/os-release) {
            $osRelease = Get-Content /etc/os-release -ErrorAction SilentlyContinue
            $prettyName = $osRelease | Where-Object { $_ -match '^PRETTY_NAME=' }
            if ($prettyName) {
                $result.OSVersion = ($prettyName -split '=', 2)[1].Trim('"')
            }
        }
    }
    elseif ($IsMacOS) {
        $result.Platform = 'macOS'
        $result.IsMacOS  = $true
        $result.OSVersion = sw_vers -productVersion 2>$null
        if ($result.OSVersion) {
            $result.OSVersion = "macOS $($result.OSVersion)"
        }
    }

    return [PSCustomObject]$result
}

# 使用示例：根据平台选择不同的包安装方式
$platform = Get-PlatformInfo
Write-Host "当前平台: $($platform.Platform) ($($platform.Architecture))"
Write-Host "操作系统: $($platform.OSVersion)"
Write-Host "PowerShell 版本: $($platform.PSVersion)"

function Join-PlatformPath {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [string]$Base,

        [Parameter(Mandatory)]
        [string]$Relative
    )

    # 统一使用 [System.IO.Path] 处理，自动适配当前平台
    return [System.IO.Path]::Combine($Base, $Relative)
}

function Get-PlatformTempPath {
    [CmdletBinding()]
    param()

    if ($IsWindows) {
        return $env:TEMP
    }
    elseif ($IsMacOS -or $IsLinux) {
        $tmpDir = $env:TMPDIR
        if (-not $tmpDir) { $tmpDir = $env:XDG_RUNTIME_DIR }
        if (-not $tmpDir) { $tmpDir = '/tmp' }
        return $tmpDir
    }
    return '/tmp'
}

function Get-PlatformHomePath {
    [CmdletBinding()]
    param()

    if ($IsWindows) {
        return $env:USERPROFILE
    }
    return $env:HOME
}

function Resolve-PlatformCase {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [string]$Path
    )

    # 在区分大小写的文件系统上，验证路径的实际大小写
    if ($IsLinux) {
        if (-not (Test-Path $Path)) {
            Write-Warning "路径不存在: $Path"
            return $Path
        }
        $item = Get-Item $Path -ErrorAction SilentlyContinue
        if ($item) {
            return $item.FullName
        }
    }
    return (Resolve-Path $Path -ErrorAction SilentlyContinue).Path
}

# 使用示例：构建跨平台的配置文件路径
$homePath   = Get-PlatformHomePath
$configDir  = Join-PlatformPath $homePath '.myapp'
$configFile = Join-PlatformPath $configDir 'config.json'
$tempDir    = Get-PlatformTempPath

Write-Host "主目录: $homePath"
Write-Host "配置目录: $configDir"
Write-Host "配置文件: $configFile"
Write-Host "临时目录: $tempDir"

# 确保配置目录存在（跨平台方式）
if (-not (Test-Path $configDir)) {
    New-Item -ItemType Directory -Path $configDir -Force | Out-Null
    Write-Host "已创建配置目录: $configDir"
}

#region 包管理器抽象

function Install-PlatformPackage {
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter(Mandatory)]
        [string]$Name,

        [Parameter()]
        [switch]$Update
    )

    if ($IsWindows) {
        # 优先使用 winget，回退到 choco
        $winget = Get-Command winget -ErrorAction SilentlyContinue
        if ($winget) {
            $args = @('install', '--id', $Name, '--accept-package-agreements', '--accept-source-agreements')
            if ($Update) { $args += '--upgrade' }
            if ($PSCmdlet.ShouldProcess($Name, 'Install via winget')) {
                & winget @args
            }
        }
        else {
            $choco = Get-Command choco -ErrorAction SilentlyContinue
            if ($choco) {
                if ($PSCmdlet.ShouldProcess($Name, 'Install via chocolatey')) {
                    & choco install $Name -y
                }
            }
            else {
                Write-Error "未找到可用的包管理器（winget 或 chocolatey）"
            }
        }
    }
    elseif ($IsMacOS) {
        if ($PSCmdlet.ShouldProcess($Name, 'Install via brew')) {
            if ($Update) {
                & brew upgrade $Name
            }
            else {
                & brew install $Name
            }
        }
    }
    elseif ($IsLinux) {
        $pkgMgr = Get-LinuxPackageManager
        if ($PSCmdlet.ShouldProcess($Name, "Install via $pkgMgr")) {
            switch ($pkgMgr) {
                'apt'   { & sudo apt-get install -y $Name }
                'dnf'   { & sudo dnf install -y $Name }
                'yum'   { & sudo yum install -y $Name }
                'pacman' { & sudo pacman -S --noconfirm $Name }
                default { Write-Error "不支持的包管理器: $pkgMgr" }
            }
        }
    }
}

function Get-LinuxPackageManager {
    [CmdletBinding()]
    param()

    if (Get-Command apt-get -ErrorAction SilentlyContinue) { return 'apt' }
    if (Get-Command dnf -ErrorAction SilentlyContinue)     { return 'dnf' }
    if (Get-Command yum -ErrorAction SilentlyContinue)     { return 'yum' }
    if (Get-Command pacman -ErrorAction SilentlyContinue)  { return 'pacman' }
    return $null
}

#endregion

#region 服务管理抽象

function Get-PlatformService {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [string]$Name
    )

    if ($IsWindows) {
        return Get-Service -Name $Name -ErrorAction SilentlyContinue
    }
    elseif ($IsLinux) {
        $status = systemctl is-active $Name 2>$null
        $enabled = systemctl is-enabled $Name 2>$null
        return [PSCustomObject]@{
            Name    = $Name
            Status  = if ($status -eq 'active') { 'Running' } else { 'Stopped' }
            Enabled = ($enabled -eq 'enabled')
        }
    }
    elseif ($IsMacOS) {
        $loaded = launchctl list $Name 2>$null
        return [PSCustomObject]@{
            Name    = $Name
            Status  = if ($loaded) { 'Running' } else { 'Stopped' }
            Enabled = [bool]$loaded
        }
    }
}

#endregion

#region 用户管理抽象

function Get-PlatformUser {
    [CmdletBinding()]
    param(
        [Parameter()]
        [string]$UserName = $env:USER
    )

    if ($IsWindows) {
        $adsi = [ADSI]"WinNT://$env:COMPUTERNAME"
        $user = $adsi.Children | Where-Object {
            $_.SchemaClassName -eq 'User' -and $_.Name -eq $UserName
        }
        if ($user) {
            return [PSCustomObject]@{
                Name        = $user.Name[0]
                FullName    = $user.FullName[0]
                Description = $user.Description[0]
                HomeDir     = Join-PlatformPath $env:USERPROFILE $user.Name[0]
                Platform    = 'Windows'
            }
        }
    }
    else {
        $passwd = getent passwd $UserName 2>$null
        if ($passwd) {
            $fields = $passwd -split ':'
            return [PSCustomObject]@{
                Name        = $fields[0]
                FullName    = ($fields[4] -split ',', 2)[0]
                Description = ''
                HomeDir     = $fields[5]
                Shell       = $fields[6]
                Platform    = if ($IsMacOS) { 'macOS' } else { 'Linux' }
            }
        }
    }
}

#endregion

# 使用示例
$platform = Get-PlatformInfo
Write-Host "`n===== 跨平台工具函数演示 ====="
Write-Host "平台: $($platform.Platform)"

$currentUser = Get-PlatformUser
Write-Host "当前用户: $($currentUser.Name)"
Write-Host "主目录: $($currentUser.HomeDir)"

$tempPath = Get-PlatformTempPath
Write-Host "临时目录: $tempPath"

# 查看当前 PowerShell 版本，确认是否支持 SSH Remoting
$PSVersionTable.PSVersion

# 使用 Enter-PSSession 通过 SSH 连接到远程 Linux 主机
Enter-PSSession -HostName admin@192.168.1.100
# 在远程会话中执行命令
hostname
uname -a
whoami
# 退出远程会话
Exit-PSSession

# 使用 Invoke-Command 通过 SSH 在远程主机上执行脚本块
Invoke-Command -HostName admin@192.168.1.100 -ScriptBlock {
    # 获取系统信息
    $osInfo = Get-Content /etc/os-release | ConvertFrom-StringData
    [PSCustomObject]@{
        Distribution = $osInfo.NAME
        Version      = $osInfo.VERSION
        Kernel       = uname -r
        Uptime       = (uptime -p)
        MemoryTotal  = "#{math.Round((Get-Content /proc/meminfo |
            Select-String 'MemTotal').ToString().Split()[1] / 1MB, 2)} GB"
    }
}

# 指定 SSH 端口（非默认 22 端口的情况）
$session = New-PSSession -HostName admin@192.168.1.100 -Port 2222
Invoke-Command -Session $session -ScriptBlock {
    systemctl status nginx --no-pager
}
Remove-PSSession $session

# 生成 SSH 密钥对（如果尚未生成）
ssh-keygen -t ed25519 -C "powershell-remoting" -f ~/.ssh/id_ed25519

# 将公钥复制到远程主机（使用 ssh-copy-id）
ssh-copy-id -i ~/.ssh/id_ed25519.pub admin@192.168.1.100
ssh-copy-id -i ~/.ssh/id_ed25519.pub admin@192.168.1.101
ssh-copy-id -i ~/.ssh/id_ed25519.pub admin@192.168.1.102

# 配置 SSH config 文件，简化连接管理
$sshConfig = @"
Host web-server
    HostName 192.168.1.100
    User admin
    Port 22
    IdentityFile ~/.ssh/id_ed25519

Host db-server
    HostName 192.168.1.101
    User admin
    Port 22
    IdentityFile ~/.ssh/id_ed25519

Host app-server
    HostName 192.168.1.102
    User admin
    Port 2222
    IdentityFile ~/.ssh/id_ed25519
"@

# 将配置写入 SSH config 文件
$sshConfigPath = "$HOME/.ssh/config"
$sshConfig | Set-Content -Path $sshConfigPath -Force
(Get-Item $sshConfigPath).Attributes = 'ReadOnly'

# 使用 SSH 别名直接连接（无需输入密码）
Enter-PSSession -HostName web-server

# 通过密钥认证在多台主机上并行执行命令
$servers = @('web-server', 'db-server', 'app-server')
$results = Invoke-Command -HostName $servers -ScriptBlock {
    [PSCustomObject]@{
        Host      = $env:COMPUTERNAME ?? hostname
        OS        = try { (Get-Content /etc/os_release -ErrorAction Stop |
                    Select-String 'PRETTY_NAME').ToString().Split('"')[1] }
                  catch { $PSVersionTable.OS }
        PSVersion = $PSVersionTable.PSVersion.ToString()
        CPU_Usage = (Get-Process | Measure-Object CPU -Maximum).Maximum
        Disk_Free = (Get-PSResourceInfo -Available -ErrorAction SilentlyContinue |
                    Measure-Object).Count
    }
} | Select-Object Host, OS, PSVersion

$results | Format-Table -AutoSize

# 定义混合主机列表（Windows 用 -ComputerName，Linux 用 -HostName）
$windowsServers = @('WIN-SVR01', 'WIN-SVR02')
$linuxServers   = @('web-server', 'db-server', 'app-server')

# Windows 主机通过 WinRM 获取信息
$winResults = Invoke-Command -ComputerName $windowsServers -ScriptBlock {
    [PSCustomObject]@{
        Host        = $env:COMPUTERNAME
        Platform    = 'Windows'
        OS_Version  = [System.Environment]::OSVersion.VersionString
        CPU_Count   = $env:NUMBER_OF_PROCESSORS
        Memory_GB   = [math]::Round(
            (Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB, 2
        )
        Disk_Free_GB = [math]::Round(
            (Get-CimInstance Win32_LogicalDisk -Filter "DriveType=3" |
             Measure-Object FreeSpace -Sum).Sum / 1GB, 2
        )
        Uptime_Days = ((Get-Date) - (Get-CimInstance Win32_OperatingSystem).
                       LastBootUpTime).Days
    }
}

# Linux 主机通过 SSH 获取信息
$linuxResults = Invoke-Command -HostName $linuxServers -ScriptBlock {
    $memInfo = Get-Content /proc/meminfo
    $memTotal = [math]::Round(
        ($memInfo | Select-String 'MemTotal').ToString().Split()[1] / 1MB, 2
    )
    $diskFree = [math]::Round(
        (df -BG / | Select-Object -Last 1).ToString().Split()[3] -replace 'G',''
    )
    $uptimeDays = [math]::Floor(
        (Get-Content /proc/uptime).ToString().Split('.')[0] / 86400
    )

    [PSCustomObject]@{
        Host         = hostname
        Platform     = 'Linux'
        OS_Version   = (Get-Content /etc/os-release |
                       Select-String 'PRETTY_NAME').ToString().Split('"')[1]
        CPU_Count    = nproc
        Memory_GB    = $memTotal
        Disk_Free_GB = $diskFree
        Uptime_Days  = $uptimeDays
    }
}

# 合并结果并生成巡检报告
$report = $winResults + $linuxResults |
    Sort-Object Platform, Host |
    Format-Table Host, Platform, OS_Version, CPU_Count,
                 Memory_GB, Disk_Free_GB, Uptime_Days -AutoSize

$report | Out-String | Write-Host

# 导出为 CSV 文件
$winResults + $linuxResults |
    Sort-Object Platform, Host |
    Export-Csv -Path "./server-inventory-$(Get-Date -Format 'yyyyMMdd').csv" `
               -NoTypeInformation -Encoding UTF8

Write-Host "巡检报告已导出到 CSV 文件" -ForegroundColor Green

# 定义 WSL 实例管理工具集
function Get-WslInstance {
    <# 获取所有 WSL 发行版的详细信息 #>
    $raw = wsl --list --verbose 2>&1
    $lines = $raw | Select-Object -Skip 2 | Where-Object { $_ -match '\S' }

    foreach ($line in $lines) {
        $parts = $line.Trim() -split '\s+'
        [PSCustomObject]@{
            IsDefault = $line -match '^\*'
            Name      = $parts[0] -replace '^\*', ''
            State     = $parts[1]
            Version   = $parts[2]
        }
    }
}

function Export-WslInstance {
    <# 将 WSL 实例导出为 tar 文件，用于备份或迁移 #>
    param(
        [Parameter(Mandatory)][string]$Name,
        [Parameter(Mandatory)][string]$OutputPath
    )

    if (-not (Test-Path (Split-Path $OutputPath -Parent))) {
        New-Item -ItemType Directory -Path (Split-Path $OutputPath -Parent) -Force |
            Out-Null
    }

    Write-Host "正在导出 $Name ..." -ForegroundColor Cyan
    wsl --export $Name $OutputPath

    $size = [math]::Round((Get-Item $OutputPath).Length / 1GB, 2)
    Write-Host "导出完成：$OutputPath (${size} GB)" -ForegroundColor Green
}

function Import-WslInstance {
    <# 从 tar 文件导入为新的 WSL 实例 #>
    param(
        [Parameter(Mandatory)][string]$Name,
        [Parameter(Mandatory)][string]$InstallPath,
        [Parameter(Mandatory)][string]$SourceFile
    )

    if (-not (Test-Path $InstallPath)) {
        New-Item -ItemType Directory -Path $InstallPath -Force | Out-Null
    }

    Write-Host "正在导入 $Name ..." -ForegroundColor Cyan
    wsl --import $Name $InstallPath $SourceFile
    Write-Host "导入完成：$Name => $InstallPath" -ForegroundColor Green
}

function Remove-WslInstance {
    <# 注销并删除 WSL 实例（谨慎使用） #>
    param(
        [Parameter(Mandatory)][string]$Name,
        [switch]$Force
    )

    if (-not $Force) {
        $confirm = Read-Host "确认要删除 WSL 实例 '$Name' 吗？(yes/no)"
        if ($confirm -ne 'yes') {
            Write-Host "已取消" -ForegroundColor Yellow
            return
        }
    }

    wsl --unregister $Name
    Write-Host "已删除 WSL 实例：$Name" -ForegroundColor Red
}

# 批量备份所有运行中的实例
$instances = Get-WslInstance | Where-Object State -eq 'Running'
$backupDir = "D:\WSL-Backups\$(Get-Date -Format 'yyyyMMdd')"

foreach ($inst in $instances) {
    $tar = Join-Path $backupDir "$($inst.Name).tar"
    Export-WslInstance -Name $inst.Name -OutputPath $tar
}

# 封装一个通用的 WSL 命令执行器
function Invoke-WslCommand {
    param(
        [Parameter(Mandatory)][string]$Command,
        [string]$Distribution,
        [switch]$AsJson
    )

    $args = @()
    if ($Distribution) { $args += '-d', $Distribution }
    $args += '--', 'bash', '-c', $Command

    $result = & wsl @args 2>&1
    $result = $result | Out-String

    if ($AsJson -and $result) {
        try {
            return $result | ConvertFrom-Json
        } catch {
            Write-Warning "JSON 解析失败，返回原始文本"
            return $result
        }
    }
    return $result.Trim()
}

# 场景 1：用 Linux 工具分析 Windows 日志
# 先用 PowerShell 导出事件日志为 CSV，再用 WSL 的 awk 统计
$csvPath = "$env:TEMP\security_events.csv"
Get-WinEvent -LogName Security -MaxEvents 500 |
    Select-Object TimeCreated, Id, LevelDisplayName, Message |
    Export-Csv $csvPath -NoTypeInformation -Encoding UTF8

# 将 Windows 路径转为 WSL 可访问的路径
$wslCsv = ($csvPath -replace '^([A-Z]):', { '/mnt/' + $_.Groups[1].Value.ToLower() } `
    -replace '\\', '/')

$stats = Invoke-WslCommand "awk -F',' '{print `$3}' $wslCsv | sort | uniq -c | sort -rn"
Write-Host "安全事件级别分布：" -ForegroundColor Cyan
Write-Host $stats

# 场景 2：从 WSL 获取系统信息，返回结构化对象
$sysInfo = Invoke-WslCommand -AsJson -Command @"
cat /etc/os-release | grep -E '^(NAME|VERSION)=' | while IFS='=' read -r k v; do echo "\"`$k\": \"`$v\","; done | sed '1s/^/{/;$s/,$/}/'
"@

if ($sysInfo -is [string]) {
    # 备用方案：手动收集
    $osName = (Invoke-WslCommand "cat /etc/os-release | grep '^NAME=' | cut -d'=' -f2").Trim('"')
    $osVer = (Invoke-WslCommand "cat /etc/os-release | grep '^VERSION=' | cut -d'=' -f2").Trim('"')
    $sysInfo = [PSCustomObject]@{ NAME = $osName; VERSION = $osVer }
}

Write-Host "`nWSL 系统信息：" -ForegroundColor Cyan
Write-Host "  发行版：$($sysInfo.NAME)"
Write-Host "  版本：$($sysInfo.VERSION)"

# 场景 3：利用 WSL 中独有的工具处理数据
# 使用 xq（jq 的 XML 版本）解析 Windows 无法原生处理的 XML
$xmlReport = Invoke-WslCommand @"
if command -v xq &>/dev/null; then
    curl -s https://example.com/feed.xml | xq '.rss.channel.item[] | .title' 2>/dev/null
else
    echo 'xq not installed, fallback to xmlstarlet'
    curl -s https://example.com/feed.xml | xmlstarlet sel -t -m '//item/title' -v '.' -n 2>/dev/null
fi
"@

Write-Host "`nRSS 标题提取：" -ForegroundColor Cyan
Write-Host $xmlReport

# 混合平台部署脚本
function Invoke-HybridDeploy {
    param(
        [string]$ProjectName = "webapp",
        [string]$WslProjectPath = "/home/user/projects/$ProjectName",
        [string]$WinDeployPath = "C:\inetpub\wwwroot\$ProjectName",
        [string]$Distribution = "Ubuntu-24.04"
    )

    # 阶段 1：在 WSL 中拉取代码并构建
    Write-Host "`n[1/4] 在 WSL 中拉取最新代码..." -ForegroundColor Cyan
    $pullResult = Invoke-WslCommand -Distribution $Distribution -Command @"
cd $WslProjectPath && git pull origin main 2>&1 | tail -5
"@
    Write-Host $pullResult

    # 阶段 2：在 WSL 中执行 npm 构建
    Write-Host "`n[2/4] 在 WSL 中执行构建..." -ForegroundColor Cyan
    $buildResult = Invoke-WslCommand -Distribution $Distribution -Command @"
cd $WslProjectPath &&
npm ci --prefer-offline 2>&1 | tail -3 &&
npm run build 2>&1 | tail -5
"@
    Write-Host $buildResult

    # 阶段 3：将构建产物从 WSL 文件系统复制到 Windows
    Write-Host "`n[3/4] 复制构建产物到 Windows..." -ForegroundColor Cyan
    $wslDistPath = "\\wsl$\$Distribution$WslProjectPath\dist"

    if (Test-Path $WinDeployPath) {
        $backup = "$WinDeployPath.bak.$(Get-Date -Format 'yyyyMMdd_HHmmss')"
        Move-Item $WinDeployPath $backup -Force
        Write-Host "已备份旧版本到 $backup" -ForegroundColor Yellow
    }

    Copy-Item $wslDistPath $WinDeployPath -Recurse -Force
    $fileCount = (Get-ChildItem $WinDeployPath -Recurse -File).Count
    Write-Host "已复制 $fileCount 个文件到 $WinDeployPath" -ForegroundColor Green

    # 阶段 4：用 PowerShell 进行 Windows 端配置
    Write-Host "`n[4/4] 更新 IIS 配置..." -ForegroundColor Cyan

    # 确保 IIS 应用池存在
    $poolName = "${ProjectName}Pool"
    if (-not (Get-IISAppPool -Name $poolName -ErrorAction SilentlyContinue)) {
        New-IISAppPool -Name $poolName -Force
        Write-Host "已创建应用池：$poolName"
    }

    # 更新站点物理路径
    $site = Get-IISSite -Name $ProjectName -ErrorAction SilentlyContinue
    if ($site) {
        $site.Applications["/"].VirtualDirectories["/"].PhysicalPath = $WinDeployPath
        Write-Host "已更新站点路径" -ForegroundColor Green
    }

    # 验证部署结果
    $indexPath = Join-Path $WinDeployPath "index.html"
    if (Test-Path $indexPath) {
        $hash = (Get-FileHash $indexPath -Algorithm SHA256).Hash.Substring(0, 16)
        Write-Host "`n部署成功！index.html 校验：$hash" -ForegroundColor Green
    }

    # 阶段 5：健康检查（用 WSL 中的 curl）
    Write-Host "`n健康检查..." -ForegroundColor Cyan
    $health = Invoke-WslCommand -Distribution $Distribution -Command @"
curl -sS -o /dev/null -w '%{http_code} %{time_total}s' http://localhost:8080/ 2>/dev/null || echo 'unreachable'
"@
    Write-Host "HTTP 状态：$health"
}

# 执行部署
Invoke-HybridDeploy -ProjectName "webapp"

# 场景：读取应用配置，合并默认值，根据环境执行不同的部署步骤

# 默认配置
$defaultConfig = @{
    Port        = 8080
    MaxRetry    = 3
    LogLevel    = "Information"
    BasePath    = "/opt/app"
    Features    = @("auth", "logging")
}

# 模拟从环境变量读取的配置（部分字段缺失）
$envConfig = @{
    Port     = 9090
    LogLevel = $null
    BasePath = $null
}

# 三元运算符：根据环境决定日志前缀
$env = $env:APP_ENV ?? "development"
$logPrefix = ($env -eq "production") ? "[PROD]" : "[DEV]"

# null 合并运算符 ?? ：用默认值填充缺失的配置
$port     = $envConfig.Port ?? $defaultConfig.Port
$maxRetry = $envConfig.MaxRetry ?? $defaultConfig.MaxRetry
$logLevel = $envConfig.LogLevel ?? $defaultConfig.LogLevel
$basePath = $envConfig.BasePath ?? $defaultConfig.BasePath

# null 条件赋值 ??= ：只在变量为 null 时赋值
$features = $envConfig.Features
$features ??= $defaultConfig.Features

Write-Host "$logPrefix 应用配置已加载"
Write-Host "  端口: $port"
Write-Host "  最大重试: $maxRetry"
Write-Host "  日志级别: $logLevel"
Write-Host "  基础路径: $basePath"
Write-Host "  功能模块: $($features -join ', ')"

# 管道链操作符 && 和 ||
Write-Host "`n--- 部署流程 ---"

# && 前面的命令成功才执行后面的命令
# || 前面的命令失败才执行后面的命令
Test-Path $basePath && Write-Host "目录已存在: $basePath" || Write-Host "目录不存在，将使用默认路径"

# 构建最终配置对象
$appConfig = [PSCustomObject]@{
    Port     = $port
    MaxRetry = $maxRetry
    LogLevel = $logLevel
    BasePath = $basePath
    Features = $features
    Env      = $env
    Prefix   = $logPrefix
}

Write-Host "`n最终配置:"
$appConfig | Format-List

# 场景：批量检查远程服务器的健康状态

# 模拟服务器列表
$servers = @(
    "web-prod-01", "web-prod-02", "web-prod-03",
    "api-prod-01", "api-prod-02",
    "db-prod-01",  "db-prod-02",
    "cache-prod-01", "cache-prod-02", "cache-prod-03"
)

# 模拟健康检查函数（实际环境中会调用 Invoke-RestMethod 或 Test-Connection）
function Test-ServerHealth {
    param([string]$ServerName)

    # 模拟网络延迟
    Start-Sleep -Milliseconds (Get-Random -Min 100 -Max 500)

    $statuses = @("健康", "健康", "健康", "警告", "健康", "异常")
    $status = $statuses | Get-Random

    return [PSCustomObject]@{
        Server   = $ServerName
        Status   = $status
        CpuUsage = [math]::Round((Get-Random -Min 10 -Max 95), 1)
        MemUsage = [math]::Round((Get-Random -Min 20 -Max 90), 1)
        CheckAt  = Get-Date -Format "HH:mm:ss"
    }
}

# 串行执行（作为对比）
$serialWatch = [System.Diagnostics.Stopwatch]::StartNew()
$serialResults = $servers | ForEach-Object {
    Test-ServerHealth -ServerName $_
}
$serialWatch.Stop()

Write-Host "串行执行耗时: $($serialWatch.ElapsedMilliseconds) ms"
Write-Host "串行结果数: $($serialResults.Count)"

# 并行执行（限制并发数为 4）
$parallelWatch = [System.Diagnostics.Stopwatch]::StartNew()
$parallelResults = $servers | ForEach-Object -ThrottleLimit 4 -Parallel {
    # 注意：-Parallel 脚本块内无法直接访问外部变量和函数
    # 需要通过 $using: 引用外部变量，或重新定义函数

    # 在脚本块内定义健康检查逻辑
    $statuses = @("健康", "健康", "健康", "警告", "健康", "异常")
    $status = $statuses | Get-Random

    # 模拟网络延迟
    Start-Sleep -Milliseconds (Get-Random -Min 100 -Max 500)

    [PSCustomObject]@{
        Server   = $_
        Status   = $status
        CpuUsage = [math]::Round((Get-Random -Min 10 -Max 95), 1)
        MemUsage = [math]::Round((Get-Random -Min 20 -Max 90), 1)
        CheckAt  = Get-Date -Format "HH:mm:ss"
    }
}
$parallelWatch.Stop()

Write-Host "`n并行执行耗时: $($parallelWatch.ElapsedMilliseconds) ms"
Write-Host "并行结果数: $($parallelResults.Count)"

# 使用 $using: 传递外部变量的示例
$timeoutSec = 5
$parallelWithUsing = $servers | ForEach-Object -ThrottleLimit 4 -Parallel {
    $timeout = $using:timeoutSec
    # 可以在日志中引用外部配置
    [PSCustomObject]@{
        Server  = $_
        Timeout = $timeout
        Message = "超时设置: ${timeout}s，检查完成"
    }
}

# 输出加速比
$speedup = [math]::Round($serialWatch.ElapsedMilliseconds / $parallelWatch.ElapsedMilliseconds, 1)
Write-Host "`n加速比: ${speedup}x"

# 汇总健康状态
Write-Host "`n--- 健康检查汇总 ---"
$parallelResults | Group-Object Status | ForEach-Object {
    Write-Host "  $($_.Name): $($_.Count) 台"
}

# 筛选异常服务器
$unhealthy = $parallelResults | Where-Object { $_.Status -ne "健康" }
if ($unhealthy) {
    Write-Host "`n需要关注的服务器:"
    $unhealthy | Format-Table -AutoSize
}

# 场景：编写一个跨平台的系统信息收集脚本

# 自动适应的路径处理
# PowerShell 7 对 Join-Path 和路径处理做了跨平台优化
function Get-SystemReport {
    $report = [ordered]@{}

    # 平台检测
    $report["操作系统"] = [System.Environment]::OSVersion.Platform.ToString()
    $report["机器名"] = [System.Environment]::MachineName
    $report["PowerShell 版本"] = $PSVersionTable.PSVersion.ToString()
    $report["是否为管理员"] = (
        [System.Security.Principal.WindowsPrincipal]::new(
            [System.Security.Principal.WindowsIdentity]::GetCurrent()
        ).IsInRole("Administrators")
    ) ? "是" : "否"

    # 跨平台路径处理
    $configDir = Join-Path $HOME "app-config"
    $logDir = Join-Path $HOME "app-logs"
    $dataFile = Join-Path $configDir "data.json"

    $report["配置目录"] = $configDir
    $report["日志目录"] = $logDir

    # 创建目录（跨平台兼容）
    $null = New-Item -ItemType Directory -Path $configDir -Force
    $null = New-Item -ItemType Directory -Path $logDir -Force

    # 跨平台环境变量访问
    $report["用户主目录"] = $HOME
    $report["PATH 条目数"] = ($env:PATH -split ([System.IO.Path]::PathSeparator)).Count
    $report["临时目录"] = [System.IO.Path]::GetTempPath()

    # 根据平台使用不同的系统信息获取方式
    if ($IsWindows) {
        # Windows 平台：使用 CIM 获取详细信息
        $os = Get-CimInstance -ClassName Win32_OperatingSystem
        $report["系统版本"] = $os.Caption
        $report["可用内存(MB)"] = [math]::Round($os.FreePhysicalMemory / 1024, 0)
        $report["CPU 核心数"] = (Get-CimInstance -ClassName Win32_Processor).NumberOfLogicalProcessors
    }
    elseif ($IsLinux) {
        # Linux 平台：读取 /proc 文件系统
        $report["系统版本"] = (Get-Content /etc/os-release |
            Where-Object { $_ -match "^PRETTY_NAME=" }) -replace 'PRETTY_NAME="(.+)"', '$1'
        $report["可用内存(MB)"] = [math]::Round(
            (Get-Content /proc/meminfo |
                Where-Object { $_ -match "^MemAvailable:" } |
                ForEach-Object { ($_ -split '\s+')[1] }) / 1024, 0
        )
        $report["CPU 核心数"] = (Get-Content /proc/cpuinfo |
            Where-Object { $_ -match "^processor" }).Count
    }
    elseif ($IsMacOS) {
        $report["系统版本"] = "macOS $(sw_vers -productVersion 2>$null)"
        $report["CPU 核心数"] = [int](sysctl -n hw.ncpu 2>$null)
    }

    # 写入配置文件（跨平台路径）
    $reportJson = $report | ConvertTo-Json -Depth 3
    Set-Content -Path $dataFile -Value $reportJson -Encoding UTF8

    return [PSCustomObject]$report
}

# 执行并展示结果
$systemReport = Get-SystemReport
Write-Host "`n=== 系统信息报告 ==="
$systemReport | Format-List

# 展示跨平台文件路径
Write-Host "`n=== 跨平台路径示例 ==="
$paths = @(
    (Join-Path $HOME "Documents" "notes.txt"),
    (Join-Path $HOME ".config" "app" "settings.json"),
    (Join-Path $HOME "logs" "app-$(Get-Date -Format 'yyyyMMdd').log")
)
$paths | ForEach-Object {
    Write-Host "  $($_ -replace '\\', '/')"
}

# Windows 兼容性模块提示
if ($IsWindows) {
    Write-Host "`n=== Windows 兼容性模块 ==="
    $compatModules = @(
        "Microsoft.PowerShell.Archive",
        "Microsoft.PowerShell.Management",
        "Microsoft.PowerShell.Security",
        "CimCmdlets",
        "Microsoft.WSMan.Management"
    )
    $compatModules | ForEach-Object {
        $installed = Get-Module -ListAvailable -Name $_ -ErrorAction SilentlyContinue
        $status = ($null -ne $installed) ? "已安装" : "未安装"
        Write-Host "  $_`: $status"
    }
}

# 检查 SSH 客户端是否已安装
$sshClient = Get-Command ssh -ErrorAction SilentlyContinue
if ($sshClient) {
    Write-Host "SSH 客户端版本："
    ssh -V 2>&1
} else {
    Write-Host "未找到 SSH 客户端，请先安装 OpenSSH" -ForegroundColor Red
}

# 测试到远程主机的 SSH 连通性
$remoteHost = "192.168.1.100"
$sshTest = Test-Connection -ComputerName $remoteHost -Count 2 -Quiet
if ($sshTest) {
    Write-Host "主机 $remoteHost 网络可达"
} else {
    Write-Host "主机 $remoteHost 无法访问" -ForegroundColor Yellow
}

# 定义远程主机信息
$remoteHost = "admin@192.168.1.100"
$sshPort = 22

# 创建会话选项（连接超时 30 秒）
$sessionOption = New-PSSessionOption -OpenTimeout 30000

# 通过 SSH 建立交互式会话
Enter-PSSession -HostName $remoteHost -Port $sshPort -Options $sessionOption

# 进入远程会话后，可以像本地一样执行命令
# PS /home/admin> $PSVersionTable
# PS /home/admin> Get-Process | Select-Object -First 5

# 退出远程会话
Exit-PSSession

# 定义多台远程主机
$servers = @(
    "admin@web-server-01",
    "admin@web-server-02",
    "admin@db-server-01"
)

# 批量查询远程主机的系统信息
$results = Invoke-Command -HostName $servers -ScriptBlock {
    $osInfo = Get-Content /etc/os-release |
        Where-Object { $_ -match '^PRETTY_NAME=' } |
        ForEach-Object { ($_ -split '=')[1].Trim('"') }

    $cpuUsage = (Get-Process | Measure-Object -Property CPU -Sum).Sum
    $memInfo = Get-Content /proc/meminfo |
        Where-Object { $_ -match '^MemAvailable:' }

    [PSCustomObject]@{
        HostName   = $env:COMPUTERNAME ?? hostname
        OS         = $osInfo
        CPU_Total  = [math]::Round($cpuUsage, 2)
        Mem_Info   = $memInfo
        Timestamp  = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
    }
}

# 展示结果
$results | Format-Table -AutoSize

# 检查是否已有 SSH 密钥
$sshDir = Join-Path $env:USERPROFILE ".ssh"
$keyPath = Join-Path $sshDir "id_ed25519"

if (-not (Test-Path $keyPath)) {
    # 生成新的 Ed25519 密钥（更安全、更快速）
    Write-Host "正在生成 SSH 密钥..." -ForegroundColor Cyan
    ssh-keygen -t ed25519 -f $keyPath -C "powershell-remoting" -N '""'
    Write-Host "密钥已生成：$keyPath" -ForegroundColor Green
} else {
    Write-Host "已有 SSH 密钥：$keyPath"
}

# 读取公钥内容
$publicKey = Get-Content "$keyPath.pub" -Raw
Write-Host "公钥内容（前 80 字符）："
Write-Host $publicKey.Substring(0, [Math]::Min(80, $publicKey.Length))

# 定义服务器清单
$serverList = @(
    [PSCustomObject]@{ Alias = "web01"; Host = "192.168.1.101"; User = "admin"; Port = 22 }
    [PSCustomObject]@{ Alias = "web02"; Host = "192.168.1.102"; User = "admin"; Port = 22 }
    [PSCustomObject]@{ Alias = "db01";  Host = "192.168.1.201"; User = "dba";   Port = 2222 }
    [PSCustomObject]@{ Alias = "proxy"; Host = "10.0.0.50";     User = "ops";   Port = 22 }
)

# 生成 SSH Config 内容
$configLines = @()
$configLines += "# PowerShell SSH Remoting - Auto Generated"
$configLines += ""

foreach ($server in $serverList) {
    $configLines += "Host $($server.Alias)"
    $configLines += "    HostName $($server.Host)"
    $configLines += "    User $($server.User)"
    $configLines += "    Port $($server.Port)"
    $configLines += "    IdentityFile ~/.ssh/id_ed25519"
    $configLines += "    StrictHostKeyChecking accept-new"
    $configLines += ""
}

# 写入 SSH Config 文件
$sshConfigPath = Join-Path $env:USERPROFILE ".ssh" "config"
$configLines | Set-Content -Path $sshConfigPath -Encoding UTF8
Write-Host "SSH Config 已写入：$sshConfigPath" -ForegroundColor Green

# 验证配置
Write-Host "`n配置内容预览："
Get-Content $sshConfigPath

# 使用 SSH Config 中定义的别名连接
Enter-PSSession -HostName web01

# 也可以批量执行命令
$webServers = @("web01", "web02")
$diskReport = Invoke-Command -HostName $webServers -ScriptBlock {
    $df = df -h / | Select-Object -Last 1
    $uptime = uptime -p
    [PSCustomObject]@{
        Server    = hostname
        Disk      = $df
        Uptime    = $uptime
        Collected = Get-Date -Format 'HH:mm:ss'
    }
}

$diskReport | Format-List