# 定义仓库列表
$repos = @(
    @{ Name = 'bitnami'; Url = 'https://charts.bitnami.com/bitnami' }
    @{ Name = 'ingress-nginx'; Url = 'https://kubernetes.github.io/ingress-nginx' }
    @{ Name = 'jetstack'; Url = 'https://charts.jetstack.io' }
)

# 批量添加并更新仓库
foreach ($repo in $repos) {
    helm repo add $repo.Name $repo.Url 2>$null
    Write-Host "已添加仓库: $($repo.Name)" -ForegroundColor Green
}

helm repo update

# 搜索指定关键词的 Chart，并按版本排序
$searchKeyword = 'nginx'
$charts = helm search repo $searchKeyword --output json |
    ConvertFrom-Json

$charts |
    Select-Object name, @{N='version';E={ $_.chart_version }}, app_version, description |
    Sort-Object name |
    Format-Table -AutoSize

# 对比已安装版本与仓库最新版本
$releases = helm list --all-namespaces --output json | ConvertFrom-Json

foreach ($rel in $releases) {
    $chartName = $rel.chart -replace '-\d+.*$', ''
    $installed = $rel.chart_version
    $latest = (helm search repo $chartName --output json |
        ConvertFrom-Json |
        Select-Object -First 1).chart_version

    $status = if ($installed -eq $latest) { '已是最新' } else { "可升级: $installed -> $latest" }
    Write-Host ("[{0}] {1} ({2}): {3}" -f $rel.namespace, $rel.name, $chartName, $status)
}

# 更新 Chart 依赖（针对本地 Chart）
$localChartPath = './charts/my-application'
if (Test-Path "$localChartPath/Chart.yaml") {
    helm dependency update $localChartPath
    Write-Host "依赖已更新: $localChartPath" -ForegroundColor Cyan
}

# 定义环境配置矩阵
$environments = @{
    dev = @{
        replicas    = 1
        imageTag    = 'latest'
        resources   = @{ cpuRequest = '100m'; memRequest = '128Mi' }
        ingress     = @{ enabled = $false }
    }
    staging = @{
        replicas    = 2
        imageTag    = 'v2.1.0-rc.1'
        resources   = @{ cpuRequest = '250m'; memRequest = '256Mi' }
        ingress     = @{ enabled = $true; host = 'staging.example.com' }
    }
    production = @{
        replicas    = 3
        imageTag    = 'v2.0.1'
        resources   = @{ cpuRequest = '500m'; memRequest = '512Mi' }
        ingress     = @{ enabled = $true; host = 'app.example.com'; tls = $true }
    }
}

# 为每个环境生成 values 文件
foreach ($envName in $environments.Keys) {
    $env = $environments[$envName]
    $values = [ordered]@{
        replicaCount = $env.replicas
        image        = [ordered]@{
            repository = 'registry.example.com/my-app'
            tag        = $env.imageTag
            pullPolicy = if ($env.imageTag -eq 'latest') { 'Always' } else { 'IfNotPresent' }
        }
        resources    = [ordered]@{
            requests = [ordered]@{
                cpu    = $env.resources.cpuRequest
                memory = $env.resources.memRequest
            }
        }
        ingress      = $env.ingress
    }

    $outputPath = "values-$envName.yaml"

    # 使用 ConvertTo-Yaml（或手动构建 YAML 字符串）
    # 这里用 helm 的 --set 语法验证生成结果
    $jsonContent = $values | ConvertTo-Json -Depth 10

    # 将 JSON 转为 YAML（利用 yq 或简单字符串替换）
    $jsonContent | python3 -c "import sys,yaml,json; yaml.dump(json.load(sys.stdin),open('$outputPath','w'),default_flow_style=False)"

    Write-Host "已生成: $outputPath" -ForegroundColor Green
}

# 敏感值处理：从外部密钥管理器获取
function Get-SecretForHelm {
    param([string]$SecretName)

    # 从环境变量或 Azure Key Vault / HashiCorp Vault 获取
    $value = [System.Environment]::GetEnvironmentVariable("HELM_SECRET_$SecretName")
    if (-not $value) {
        # 尝试从 kubectl secret 获取
        $value = kubectl get secret app-secrets -o jsonpath="{.data.$SecretName}" |
            base64 -d 2>$null
    }
    return $value
}

# 合并基础 values 与环境覆盖
function Merge-HelmValues {
    param($BasePath, $OverridePath, $OutputPath)

    # 使用 yq 合并 YAML 文件
    yq eval-all 'select(fileIndex == 0) * select(fileIndex == 1)' `
        $BasePath $OverridePath -o yaml > $OutputPath

    Write-Host "合并完成: $OutputPath" -ForegroundColor Cyan
}

# 生成包含敏感值的最终 values
$dbPassword = Get-SecretForHelm -SecretName 'DB_PASSWORD'
if ($dbPassword) {
    $secretValues = "database:`n  password: $dbPassword"
    $secretValues | Out-File -FilePath 'values-secrets.yaml' -Encoding utf8
    Merge-HelmValues -BasePath 'values-production.yaml' `
        -OverridePath 'values-secrets.yaml' `
        -OutputPath 'values-production-final.yaml'
}

# 定义部署清单
$deployments = @(
    @{
        Name        = 'api-gateway'
        Namespace   = 'production'
        Chart       = 'bitnami/nginx'
        ValuesFile  = 'values-production.yaml'
        Wait        = $true
    }
    @{
        Name        = 'auth-service'
        Namespace   = 'production'
        Chart       = './charts/auth-service'
        ValuesFile  = 'values-auth-production.yaml'
        Wait        = $true
    }
    @{
        Name        = 'frontend'
        Namespace   = 'production'
        Chart       = './charts/frontend'
        ValuesFile  = 'values-frontend-production.yaml'
        Wait        = $false
    }
)

# 确保 namespace 存在
$namespaces = $deployments | Select-Object -ExpandProperty Namespace -Unique
foreach ($ns in $namespaces) {
    $exists = kubectl get namespace $ns --ignore-not-found 2>$null
    if (-not $exists) {
        kubectl create namespace $ns
        Write-Host "已创建命名空间: $ns" -ForegroundColor Yellow
    }
}

# 批量部署并记录结果
$results = [System.Collections.Generic.List[PSObject]]::new()

foreach ($dep in $deployments) {
    $stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
    Write-Host "`n部署: $($dep.Name) -> $($dep.Namespace)" -ForegroundColor Cyan

    $waitFlag = if ($dep.Wait) { '--wait' } else { '' }
    $command = "helm upgrade --install $($dep.Name) $($dep.Chart) " +
        "--namespace $($dep.Namespace) " +
        "-f $($dep.ValuesFile) $waitFlag --timeout 5m"

    $output = Invoke-Expression $command 2>&1
    $stopwatch.Stop()

    $success = $LASTEXITCODE -eq 0
    $results.Add([PSCustomObject]@{
        Name       = $dep.Name
        Namespace  = $dep.Namespace
        Status     = if ($success) { 'deployed' } else { 'failed' }
        Duration   = '{0:N1}s' -f $stopwatch.Elapsed.TotalSeconds
        Output     = $output | Select-Object -First 3
    })
}

# 输出部署报告
Write-Host "`n===== 部署报告 =====" -ForegroundColor Yellow
$results |
    Select-Object Name, Namespace, Status, Duration |
    Format-Table -AutoSize

# 检查是否有失败的部署
$failed = $results | Where-Object { $_.Status -eq 'failed' }
if ($failed) {
    Write-Host "`n以下部署失败，准备回滚:" -ForegroundColor Red
    $failed | ForEach-Object { Write-Host "  - $($_.Name) ($($_.Namespace))" }

    # 一键回滚所有失败项
    foreach ($f in $failed) {
        Write-Host "`n回滚: $($f.Name)" -ForegroundColor Red
        helm rollback $f.Name --namespace $f.Namespace
        $rollbackStatus = if ($LASTEXITCODE -eq 0) { '回滚成功' } else { '回滚失败' }
        Write-Host "  $rollbackStatus"
    }
}

# 生成当前所有 Release 状态摘要
$allReleases = helm list --all-namespaces --output json | ConvertFrom-Json
$report = $allReleases |
    Select-Object name, namespace, @{N='chart';E={ $_.chart -replace '-\d+.*$', '' }},
        chart_version, status, updated |
    Sort-Object namespace, name

Write-Host "`n===== 当前 Release 状态 =====" -ForegroundColor Green
$report | Format-Table -AutoSize

# 导出报告为 CSV（可选）
$report | Export-Csv -Path "helm-deploy-report-$(Get-Date -Format 'yyyyMMdd-HHmmss').csv" `
    -NoTypeInformation -Encoding utf8
Write-Host "报告已导出到 CSV 文件" -ForegroundColor Cyan

function Compare-WinGetBaseline {
    <#
    .SYNOPSIS
    将本机已安装软件与基准版本清单对比，输出偏差报告
    .PARAMETER BaselinePath
    基准 JSON 文件路径，包含期望的软件版本
    .PARAMETER ExportCurrent
    将当前已安装软件导出为基准文件（用于首次建立基准）
    #>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [string]$BaselinePath,
        [switch]$ExportCurrent
    )

    # 采集当前已安装软件
    $rawOutput = winget list --accept-source-agreements 2>&1
    $installed = $rawOutput | Where-Object {
        $_ -match '^\S' -and
        $_ -notmatch '^Name\s+Id' -and
        $_ -notmatch '^\d+ packages'
    } | ForEach-Object {
        $parts = $_ -split '\s{2,}'
        if ($parts.Count -ge 3) {
            [PSCustomObject]@{
                Name      = $parts[0].Trim()
                Id        = $parts[1].Trim()
                Version   = if ($parts.Count -ge 4) { $parts[2].Trim() } else { '未知' }
                Available = if ($parts.Count -ge 4) { $parts[3].Trim() } else {
                    if ($parts.Count -eq 3) { $parts[2].Trim() } else { '' }
                }
            }
        }
    }

    # 导出模式：将当前状态保存为基准
    if ($ExportCurrent) {
        $baseline = $installed | ForEach-Object {
            [ordered]@{ Id = $_.Id; Version = $_.Version }
        }
        $baseline | ConvertTo-Json -Depth 3 | Set-Content $BaselinePath -Encoding UTF8
        Write-Host "基准已导出至 $BaselinePath ($($baseline.Count) 个软件包)" `
            -ForegroundColor Green
        return
    }

    # 对比模式：加载基准并与当前状态比较
    $baselineRaw = Get-Content $BaselinePath -Raw | ConvertFrom-Json
    $baselineMap = @{}
    foreach ($item in $baselineRaw) {
        $baselineMap[$item.Id] = $item.Version
    }

    $results = foreach ($pkg in $installed) {
        if ($baselineMap.ContainsKey($pkg.Id)) {
            $expected = $baselineMap[$pkg.Id]
            $status = if ($pkg.Version -eq $expected) { '匹配' }
                      elseif ([version]::TryParse($pkg.Version, [ref]$null) -and
                              [version]::TryParse($expected, [ref]$null)) {
                          if ([version]$pkg.Version -gt [version]$expected) { '更新' }
                          else { '过旧' }
                      } else { '不同' }
            [PSCustomObject]@{
                Name     = $pkg.Name
                Id       = $pkg.Id
                Current  = $pkg.Version
                Expected = $expected
                Status   = $status
            }
        }
    }

    $results | Sort-Object Status | Format-Table -AutoSize
    $summary = $results | Group-Object Status | ForEach-Object {
        "$($_.Name): $($_.Count)"
    }
    Write-Host "版本偏差汇总: $($summary -join ', ')" -ForegroundColor Cyan
}

# 首次建立基准
# Compare-WinGetBaseline -BaselinePath './baseline.json' -ExportCurrent

# 后续对比检查
# Compare-WinGetBaseline -BaselinePath './baseline.json'

function Invoke-WinGetDesiredState {
    <#
    .SYNOPSIS
    读取 YAML 声明式配置，确保软件状态与期望一致
    .PARAMETER ConfigPath
    YAML 配置文件路径
    .PARAMETER ReportOnly
    仅生成偏差报告，不执行实际安装或卸载
    #>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [string]$ConfigPath,
        [switch]$ReportOnly
    )

    # 读取 YAML 配置（需要 powershell-yaml 模块或手动解析）
    $configContent = Get-Content $ConfigPath -Raw

    # 简易 YAML 解析：提取 packages 节点下的条目
    $lines = $configContent -split "`n"
    $desiredPackages = @{}
    $currentSection = ''

    foreach ($line in $lines) {
        if ($line -match '^\s*#') { continue }
        if ($line -match '^packages:') {
            $currentSection = 'packages'
            continue
        }
        if ($currentSection -eq 'packages' -and
            $line -match '^\s{2}(\S+):\s*$') {
            $pkgId = $Matches[1]
            $desiredPackages[$pkgId] = @{ State = 'present'; Version = '' }
            $currentSection = "pkg_$pkgId"
        }
        if ($line -match '^\s{4}state:\s*(\S+)') {
            $desiredPackages[$pkgId]['State'] = $Matches[1]
        }
        if ($line -match '^\s{4}version:\s*(\S+)') {
            $desiredPackages[$pkgId]['Version'] = $Matches[1]
        }
        if ($line -match '^[^\s]') {
            $currentSection = ''
        }
    }

    # 获取当前已安装软件
    $rawOutput = winget list --accept-source-agreements 2>&1
    $installedIds = @()
    $installedMap = @{}

    $rawOutput | Where-Object {
        $_ -match '^\S' -and
        $_ -notmatch '^Name\s+Id' -and
        $_ -notmatch '^\d+ packages'
    } | ForEach-Object {
        $parts = $_ -split '\s{2,}'
        if ($parts.Count -ge 2) {
            $id = $parts[1].Trim()
            $installedIds += $id
            $installedMap[$id] = if ($parts.Count -ge 4) {
                $parts[2].Trim()
            } else { '未知' }
        }
    }

    # 计算偏差并执行收敛
    $actions = @()

    foreach ($id in $desiredPackages.Keys) {
        $desired = $desiredPackages[$id]
        if ($desired.State -eq 'present') {
            if ($id -notin $installedIds) {
                $actions += [PSCustomObject]@{
                    Action = '安装'
                    Id     = $id
                    Target = $desired.Version
                }
            } elseif ($desired.Version -and
                      $installedMap[$id] -ne $desired.Version) {
                $actions += [PSCustomObject]@{
                    Action = '版本调整'
                    Id     = $id
                    Target = "$($installedMap[$id]) -> $($desired.Version)"
                }
            }
        } elseif ($desired.State -eq 'absent' -and $id -in $installedIds) {
            $actions += [PSCustomObject]@{
                Action = '卸载'
                Id     = $id
                Target = $installedMap[$id]
            }
        }
    }

    Write-Host "配置偏差分析完成，共 $($actions.Count) 项操作:" `
        -ForegroundColor Cyan
    $actions | Format-Table -AutoSize

    if ($ReportOnly) {
        Write-Host "[报告模式] 不执行实际操作" -ForegroundColor DarkYellow
        return
    }

    foreach ($act in $actions) {
        switch ($act.Action) {
            '安装' {
                $args = @('install', '--id', $act.Id,
                    '--accept-package-agreements',
                    '--accept-source-agreements')
                if ($desiredPackages[$act.Id].Version) {
                    $args += @('--version', $desiredPackages[$act.Id].Version)
                }
                Write-Host "安装 $($act.Id)..." -ForegroundColor Yellow -NoNewline
                winget @args 2>&1 | Out-Null
            }
            '卸载' {
                Write-Host "卸载 $($act.Id)..." -ForegroundColor Yellow -NoNewline
                winget uninstall --id $act.Id 2>&1 | Out-Null
            }
            '版本调整' {
                Write-Host "调整 $($act.Id) 版本..." -ForegroundColor Yellow -NoNewline
                winget install --id $act.Id --version `
                    $desiredPackages[$act.Id].Version `
                    --force --accept-package-agreements `
                    --accept-source-agreements 2>&1 | Out-Null
            }
        }
        if ($LASTEXITCODE -eq 0) {
            Write-Host " 完成" -ForegroundColor Green
        } else {
            Write-Host " 失败 (退出码: $LASTEXITCODE)" -ForegroundColor Red
        }
    }
    Write-Host "`n状态收敛完成" -ForegroundColor Green
}

function Invoke-WinGetSafeUpdate {
    <#
    .SYNOPSIS
    安全更新：更新前快照，支持回滚
    .PARAMETER SnapshotDir
    快照存储目录
    .PARAMETER MaxRetries
    单个软件包更新失败后的最大重试次数
    .PARAMETER RollbackOnFailure
    任一软件更新失败时自动回滚所有已更新的软件
    #>
    [CmdletBinding()]
    param(
        [string]$SnapshotDir = (Join-Path $env:TEMP 'WinGetSnapshots'),
        [int]$MaxRetries = 2,
        [switch]$RollbackOnFailure
    )

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

    $timestamp = Get-Date -Format 'yyyyMMdd_HHmmss'
    $snapshotPath = Join-Path $SnapshotDir "snapshot_$timestamp.json"

    # 第一步：创建当前软件版本快照
    Write-Host "[1/4] 正在创建软件版本快照..." -ForegroundColor Cyan
    $rawOutput = winget list --accept-source-agreements 2>&1
    $snapshot = $rawOutput | Where-Object {
        $_ -match '^\S' -and
        $_ -notmatch '^Name\s+Id' -and
        $_ -notmatch '^\d+ packages'
    } | ForEach-Object {
        $parts = $_ -split '\s{2,}'
        if ($parts.Count -ge 3) {
            [ordered]@{
                Name    = $parts[0].Trim()
                Id      = $parts[1].Trim()
                Version = if ($parts.Count -ge 4) {
                    $parts[2].Trim()
                } else { '未知' }
            }
        }
    }

    $snapshot | ConvertTo-Json -Depth 3 | Set-Content $snapshotPath -Encoding UTF8
    Write-Host "快照已保存: $snapshotPath ($($snapshot.Count) 个软件包)" `
        -ForegroundColor Green

    # 第二步：扫描可更新的软件
    Write-Host "`n[2/4] 正在扫描可更新的软件..." -ForegroundColor Cyan
    $upgradeOutput = winget upgrade 2>&1
    $upgradable = $upgradeOutput | Where-Object {
        $_ -match '^\S' -and
        $_ -notmatch '^Name\s+Id' -and
        $_ -notmatch '^\d+ upgrades'
    } | ForEach-Object {
        $parts = $_ -split '\s{2,}'
        if ($parts.Count -ge 4) {
            [PSCustomObject]@{
                Name     = $parts[0].Trim()
                Id       = $parts[1].Trim()
                OldVer   = $parts[2].Trim()
                NewVer   = $parts[3].Trim()
            }
        }
    }

    if (-not $upgradable) {
        Write-Host "所有软件已是最新版本，无需更新" -ForegroundColor Green
        return
    }

    Write-Host "发现 $($upgradable.Count) 个可更新软件包:" -ForegroundColor Yellow
    $upgradable | Format-Table Name, Id, OldVer, NewVer -AutoSize

    # 第三步：逐个执行更新并记录结果
    Write-Host "`n[3/4] 开始安全更新..." -ForegroundColor Cyan
    $results = @()
    $failed = @()

    foreach ($pkg in $upgradable) {
        $success = $false
        $attempt = 0

        while (-not $success -and $attempt -lt $MaxRetries) {
            $attempt++
            Write-Host "  更新 $($pkg.Id) ($($pkg.OldVer) -> $($pkg.NewVer))" `
                -ForegroundColor Yellow -NoNewline
            if ($attempt -gt 1) {
                Write-Host " [重试 $attempt]" -ForegroundColor DarkYellow -NoNewline
            }

            winget upgrade --id $pkg.Id --accept-package-agreements `
                --accept-source-agreements 2>&1 | Out-Null

            if ($LASTEXITCODE -eq 0) {
                Write-Host " 完成" -ForegroundColor Green
                $success = $true
                $results += [PSCustomObject]@{
                    Id       = $pkg.Id
                    OldVer   = $pkg.OldVer
                    NewVer   = $pkg.NewVer
                    Status   = '成功'
                    Attempts = $attempt
                }
            } else {
                Write-Host " 失败" -ForegroundColor Red
            }
        }

        if (-not $success) {
            $failed += $pkg
            $results += [PSCustomObject]@{
                Id       = $pkg.Id
                OldVer   = $pkg.OldVer
                NewVer   = $pkg.NewVer
                Status   = '失败'
                Attempts = $MaxRetries
            }
        }
    }

    # 第四步：失败时自动回滚
    Write-Host "`n[4/4] 更新结果汇总:" -ForegroundColor Cyan
    $results | Format-Table Id, OldVer, NewVer, Status, Attempts -AutoSize

    if ($failed -and $RollbackOnFailure) {
        Write-Host "`n检测到更新失败，正在回滚到快照版本..." -ForegroundColor Red
        $snapshotData = Get-Content $snapshotPath -Raw | ConvertFrom-Json
        $updatedIds = $results | Where-Object { $_.Status -eq '成功' } |
            Select-Object -ExpandProperty Id

        foreach ($id in $updatedIds) {
            $entry = $snapshotData | Where-Object { $_.Id -eq $id }
            if ($entry -and $entry.Version -ne '未知') {
                Write-Host "  回滚 $($entry.Id) 到 $($entry.Version)..." `
                    -ForegroundColor Yellow -NoNewline
                winget install --id $entry.Id --version $entry.Version `
                    --force --accept-package-agreements `
                    --accept-source-agreements 2>&1 | Out-Null
                if ($LASTEXITCODE -eq 0) {
                    Write-Host " 完成" -ForegroundColor Green
                } else {
                    Write-Host " 回滚失败" -ForegroundColor Red
                }
            }
        }
        Write-Host "回滚流程结束" -ForegroundColor Cyan
    } elseif ($failed) {
        Write-Host "`n提示: 更新失败的软件可使用以下命令手动回滚:" -ForegroundColor Yellow
        Write-Host "  回滚快照文件: $snapshotPath" -ForegroundColor DarkYellow
        foreach ($f in $failed) {
            Write-Host "  winget install --id $($f.Id) " + `
                "--version $($f.OldVer) --force" -ForegroundColor DarkYellow
        }
    }

    Write-Host "`n快照文件: $snapshotPath" -ForegroundColor DarkGray
    Write-Host "可使用以下命令查看历史快照: Get-ChildItem $SnapshotDir" `
        -ForegroundColor DarkGray
}

# 安装 PSResourceGet 模块（如果尚未安装）
Install-Module Microsoft.PowerShell.PSResourceGet -Force -Scope CurrentUser

# 查看已注册的仓库
Get-PSResourceRepository

# 注册额外的仓库，例如自定义的 NuGet 源
Register-PSResourceRepository -Name 'MyCompanyFeed' -Uri 'https://nuget.mycompany.com/v3/index.json'

# 搜索模块：在所有仓库中查找包含 "Az" 关键字的模块
Find-PSResource -Name '*Az*' -Type Module -Repository 'PSGallery' | Select-Object Name, Version, Description | Format-Table -AutoSize

# 安装指定模块的最新稳定版本
Install-PSResource -Name 'Pester' -Scope CurrentUser -TrustRepository

# 安装指定版本的模块
Install-PSResource -Name 'Pester' -Version '5.5.0' -Scope CurrentUser

# 更新已安装的模块到最新版本
Update-PSResource -Name 'Pester' -Scope CurrentUser

# 查看本地已安装的模块信息
Get-InstalledPSResource -Name 'Pester'

# 安装精确版本（版本锁定）
Install-PSResource -Name 'Az.Accounts' -Version '3.0.0' -Scope CurrentUser

# 安装版本范围内的最新版本（支持 NuGet 版本范围语法）
# [3.0.0, 4.0.0) 表示大于等于 3.0.0 且小于 4.0.0
Install-PSResource -Name 'Az.Accounts' -Version '[3.0.0, 4.0.0)' -Scope CurrentUser

# 安装预发布版本
Install-PSResource -Name 'Pester' -Version '6.0.0' -Prerelease -Scope CurrentUser

# 查看模块的依赖关系
$resource = Find-PSResource -Name 'Az.Compute' -Repository 'PSGallery'
$resource.Dependencies | Format-Table Name, VersionRange -AutoSize

# 导出当前环境的模块清单（用于版本锁定文件）
$installed = Get-InstalledPSResource
$lockData = $installed | ForEach-Object {
    [PSCustomObject]@{
        Name    = $_.Name
        Version = $_.Version
    }
}
$lockData | ConvertTo-Json -Depth 3 | Set-Content -Path './modules.lock.json' -Encoding UTF8

# 根据锁定文件批量恢复模块
$lock = Get-Content -Path './modules.lock.json' -Raw | ConvertFrom-Json
foreach ($entry in $lock) {
    Install-PSResource -Name $entry.Name -Version $entry.Version -Scope CurrentUser -ErrorAction SilentlyContinue
}

# ========== 服务端：搭建 NuGet.Server ==========

# 安装 NuGet.Server 包（在一台有 IIS 的 Windows 服务器上执行）
# 首先确保 NuGet 包源已注册
Register-PackageSource -Name 'NuGetGallery' -Location 'https://www.nuget.org/api/v2' -ProviderName NuGet -Trusted

# 创建 NuGet.Server 站点的目录
$sitePath = 'C:\PSGallery\Private'
New-Item -ItemType Directory -Path $sitePath -Force

# 使用 dotnet 方式创建 NuGet.Server（需要 .NET SDK）
# 或者直接下载 NuGet.Server 包并解压
Save-Package -Name NuGet.Server -Source 'NuGetGallery' -Path $sitePath

# 将自定义模块打包为 nupkg 并发布到私有仓库
$modulePath = 'C:\Modules\MyUtils'
$nupkgOutput = 'C:\PSGallery\Packages'

# 使用 PSResourceGet 发布模块
Publish-PSResource -Path $modulePath -Repository 'MyCompanyFeed' -ApiKey 'your-api-key-here'

# ========== 客户端：从私有仓库安装 ==========

# 在客户端机器上注册私有仓库
Register-PSResourceRepository -Name 'CompanyGallery' -Uri 'https://psgallery.mycompany.com/v3/index.json' -Trusted

# 设置默认仓库优先级（私有仓库优先于公网）
Set-PSResourceRepository -Name 'CompanyGallery' -Priority 1

# 从私有仓库搜索和安装模块
Find-PSResource -Name 'MyUtils' -Repository 'CompanyGallery'
Install-PSResource -Name 'MyUtils' -Repository 'CompanyGallery' -Scope CurrentUser

# 验证模块来源
Get-InstalledPSResource -Name 'MyUtils' | Select-Object Name, Version, Repository

# 搜索软件包
function Find-WinGetPackage {
    param(
        [Parameter(Mandatory)]
        [string]$Keyword
    )

    $result = winget search $Keyword --accept-source-agreements 2>&1
    $result
}

# 安装软件包
function Install-WinGetPackage {
    param(
        [Parameter(Mandatory)]
        [string]$PackageId,

        [switch]$Silent
    )

    $args = @(
        'install'
        '--id', $PackageId
        '--accept-source-agreements'
        '--accept-package-agreements'
    )

    if ($Silent) {
        $args += '--silent'
    }

    Write-Host "正在安装: $PackageId" -ForegroundColor Cyan
    winget @args 2>&1
}

# 列出已安装的软件
function Get-WinGetInstalled {
    $output = winget list --accept-source-agreements 2>&1
    $output
}

# 示例：搜索 VS Code
Find-WinGetPackage -Keyword "Visual Studio Code"

# 示例：安装 VS Code（静默模式）
Install-WinGetPackage -PackageId 'Microsoft.VisualStudioCode' -Silent

# 示例：查看已安装的软件列表
Get-WinGetInstalled

# 定义软件清单（可以保存为外部 JSON 文件）
$softwareList = @(
    @{
        Id       = 'Microsoft.VisualStudioCode'
        Name     = 'Visual Studio Code'
        Category = 'Editor'
    }
    @{
        Id       = 'Git.Git'
        Name     = 'Git for Windows'
        Category = 'VCS'
    }
    @{
        Id       = 'Microsoft.PowerShell'
        Name     = 'PowerShell 7'
        Category = 'Runtime'
    }
    @{
        Id       = 'OpenJS.NodeJS.LTS'
        Name     = 'Node.js LTS'
        Category = 'Runtime'
    }
    @{
        Id       = 'Docker.DockerDesktop'
        Name     = 'Docker Desktop'
        Category = 'Container'
    }
) | ConvertTo-Json -Depth 3

# 将清单保存到文件
$listPath = Join-Path $HOME 'winget-software-list.json'
$softwareList | Out-File -FilePath $listPath -Encoding utf8
Write-Host "软件清单已保存到: $listPath" -ForegroundColor Green

# 从文件加载并批量安装
function Install-WinGetFromList {
    param(
        [Parameter(Mandatory)]
        [string]$ListFile,

        [string[]]$Categories
    )

    $packages = Get-Content $ListFile -Raw | ConvertFrom-Json

    # 按类别过滤
    if ($Categories) {
        $packages = $packages | Where-Object { $_.Category -in $Categories }
    }

    $total = $packages.Count
    $success = 0
    $failed = 0

    foreach ($pkg in $packages) {
        Write-Host "`n[$($success + $failed + 1)/$total] 安装: $($pkg.Name)" -ForegroundColor Cyan

        $output = winget install --id $pkg.Id `
            --accept-source-agreements `
            --accept-package-agreements `
            --silent 2>&1

        $lastLine = ($output | Select-Object -Last 1).ToString()
        if ($lastLine -match '成功|successfully|已安装') {
            Write-Host "  -> 成功" -ForegroundColor Green
            $success++
        } else {
            Write-Host "  -> 失败: $lastLine" -ForegroundColor Red
            $failed++
        }
    }

    # 输出汇总报告
    Write-Host "`n===== 安装汇总 =====" -ForegroundColor Yellow
    Write-Host "总计: $total | 成功: $success | 失败: $failed"
}

# 示例：仅安装 Runtime 类别的软件
Install-WinGetFromList -ListFile $listPath -Categories 'Runtime', 'VCS'

# 检查可更新的软件
function Get-WinGetUpdate {
    $output = winget upgrade --accept-source-agreements 2>&1

    # 解析输出获取可更新的包列表
    $lines = $output -split "`n"
    $updates = @()

    # 找到数据行（跳过标题和分隔线）
    $dataStarted = $false
    foreach ($line in $lines) {
        if ($line -match '^[-\s]+$') {
            $dataStarted = $true
            continue
        }
        if ($dataStarted -and $line.Trim() -and $line -notmatch '^\s*$') {
            $updates += $line.Trim()
        }
    }

    return $updates
}

# 执行更新
function Start-WinGetUpdate {
    param(
        [string]$PackageId,

        [switch]$All,

        [switch]$WhatIf
    )

    if ($All) {
        Write-Host "检查所有可更新的软件..." -ForegroundColor Cyan
        $updates = Get-WinGetUpdate

        if ($updates.Count -eq 0) {
            Write-Host "所有软件均为最新版本" -ForegroundColor Green
            return
        }

        Write-Host "发现 $($updates.Count) 个可更新的软件:`n"
        $updates | ForEach-Object { Write-Host "  - $_" }

        if ($WhatIf) {
            Write-Host "`n[WhatIf 模式] 跳过实际更新" -ForegroundColor Yellow
            return
        }

        $confirm = Read-Host "`n确认更新全部? (Y/N)"
        if ($confirm -eq 'Y') {
            winget upgrade --all `
                --accept-source-agreements `
                --accept-package-agreements 2>&1
        }
    }
    elseif ($PackageId) {
        if ($WhatIf) {
            Write-Host "[WhatIf 模式] 将更新: $PackageId" -ForegroundColor Yellow
            return
        }

        winget upgrade --id $PackageId `
            --accept-source-agreements `
            --accept-package-agreements 2>&1
    }
}

# 定时任务：每天检查更新并记录日志
function Register-WinGetUpdateTask {
    param(
        [string]$Time = '03:00'
    )

    $scriptPath = Join-Path $HOME 'winget-auto-update.ps1'

    # 生成自动更新脚本
    $scriptContent = @"
`$logDir = Join-Path `$HOME 'WinGetUpdateLogs'
if (-not (Test-Path `$logDir)) {
    New-Item -Path `$logDir -ItemType Directory | Out-Null
}

`$logFile = Join-Path `$logDir "update-$(Get-Date -Format 'yyyy-MM-dd').log"
"[$((Get-Date))] 开始检查更新" | Out-File `$logFile -Append

`$output = winget upgrade --all --accept-source-agreements --accept-package-agreements --silent 2>&1
`$output | Out-File `$logFile -Append

"[$((Get-Date))] 更新完成" | Out-File `$logFile -Append
"@

    Set-Content -Path $scriptPath -Value $scriptContent -Encoding utf8

    # 注册计划任务
    $action = New-ScheduledTaskAction -Execute 'pwsh.exe' `
        -Argument "-NoProfile -File `"$scriptPath`""
    $trigger = New-ScheduledTaskTrigger -Daily -At $Time
    $settings = New-ScheduledTaskSettingsSet `
        -AllowStartIfOnBatteries `
        -DontStopIfGoingOnBatteries

    Register-ScheduledTask `
        -TaskName 'WinGet-AutoUpdate' `
        -Action $action `
        -Trigger $trigger `
        -Settings $settings `
        -Force

    Write-Host "已注册每日更新任务，执行时间: $Time" -ForegroundColor Green
}

# 示例：检查更新（仅查看，不执行）
Start-WinGetUpdate -All -WhatIf

# 示例：注册每日凌晨 3 点自动更新任务
# Register-WinGetUpdateTask -Time '03:00'

# 查看已注册的仓库列表
Get-PSRepository

# 恢复默认的 PSGallery 仓库
Register-PSRepository -Default

# 验证仓库是否恢复成功
Get-PSRepository

# 将 PSGallery 设为受信任源
Set-PSRepository -Name 'PSGallery' -InstallationPolicy Trusted

# 按标签搜索安全相关的模块
$modules = Find-Module -Tag 'Security' | Select-Object -First 5

foreach ($m in $modules) {
    Write-Output ("模块名: {0}, 版本: {1}, 描述: {2}" -f $m.Name, $m.Version, $m.Description)
}

# 安装指定模块到当前用户范围
Install-Module -Name 'PSScriptAnalyzer' -Scope CurrentUser -Repository PSGallery

# 确认安装成功
Get-Module -ListAvailable -Name 'PSScriptAnalyzer' | Select-Object Name, Version, ModuleBase

# 查看模块的所有可用版本
Find-Module -Name 'PSScriptAnalyzer' -AllVersions | Select-Object Name, Version | Sort-Object Version -Descending | Select-Object -First 5

# 安装指定版本
Install-Module -Name 'PSScriptAnalyzer' -RequiredVersion '1.21.0' -Scope CurrentUser -Force

# 获取所有已安装模块的当前版本和最新版本
$installedModules = Get-InstalledModule
$updateReport = @()

foreach ($mod in $installedModules) {
    $latest = Find-Module -Name $mod.Name -Repository PSGallery -ErrorAction SilentlyContinue

    if ($latest -and $latest.Version -ne $mod.Version) {
        $updateReport += [PSCustomObject]@{
            Name            = $mod.Name
            CurrentVersion  = $mod.Version
            LatestVersion   = $latest.Version
            NeedsUpdate     = $true
        }
    }
    else {
        $updateReport += [PSCustomObject]@{
            Name            = $mod.Name
            CurrentVersion  = $mod.Version
            LatestVersion   = $mod.Version
            NeedsUpdate     = $false
        }
    }
}

$updateReport | Format-Table -AutoSize

# 更新所有有新版本的模块
foreach ($mod in $updateReport) {
    if ($mod.NeedsUpdate) {
        Write-Output ("正在更新 {0} 从 {1} 到 {2}..." -f $mod.Name, $mod.CurrentVersion, $mod.LatestVersion)
        Update-Module -Name $mod.Name -Scope CurrentUser
        Write-Output ("{0} 更新完成。" -f $mod.Name)
    }
}

# 注册企业内部的 NuGet 仓库
$repoParams = @{
    Name               = 'CompanyPSRepo'
    SourceLocation     = 'https://nuget.company.com/v3/index.json'
    PublishLocation    = 'https://nuget.company.com/v3/index.json'
    InstallationPolicy = 'Trusted'
}

Register-PSRepository @repoParams

# 验证注册结果
Get-PSRepository -Name 'CompanyPSRepo'

# 搜索私有仓库中的模块
Find-Module -Repository 'CompanyPSRepo'

# 从私有仓库安装模块
Install-Module -Name 'Company.Utils' -Repository 'CompanyPSRepo' -Scope CurrentUser

# 查看模块清单信息
$modulePath = 'C:\Modules\MyToolKit'
Test-ModuleManifest -Path "$modulePath\MyToolKit.psd1" | Select-Object Name, Version, Author, Description

# 发布模块到私有仓库（使用 API Key 认证）
$publishParams = @{
    Path       = $modulePath
    Repository = 'CompanyPSRepo'
    NuGetApiKey = 'your-api-key-here'
    Verbose    = $true
}

Publish-Module @publishParams

# 检查 winget 版本
winget --version

# 搜索软件包
winget search "Visual Studio Code" --source winget

# 安装软件包
winget install --id Microsoft.VisualStudioCode --accept-package-agreements --accept-source-agreements

# 安装特定版本
winget install --id Git.Git --version 2.45.0 --accept-package-agreements

# 查看已安装的软件
winget list

# 升级所有可更新的软件
winget upgrade --all --accept-package-agreements

# 导出已安装软件列表
winget export -o C:\Config\installed-packages.json

# 从清单导入安装
winget import -i C:\Config\installed-packages.json --accept-package-agreements