param(
    [string]$ConfigPath = (Join-Path $PSScriptRoot 'config.txt'),
    [switch]$Help
)

# PAM 部署主脚本（PowerShell 实现）。
Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'

function Show-DeployUsage {
    @'
Usage:
  powershell -File .\deploy.ps1 [-ConfigPath .\config.txt]

Notes:
  - deploy.bat is only a wrapper for this script.
  - The wrapper avoids cmd.exe delayed-expansion issues with CLIENT_SECRET values
    containing exclamation marks.
'@ | Write-Host
}

function Write-Info([string]$Message) { Write-Host "[INFO] $Message" }
function Write-WarnLog([string]$Message) { Write-Host "[WARN] $Message" }
function Write-ErrLog([string]$Message) { Write-Host "[ERROR] $Message" }

function Convert-ResponseContent {
    param([AllowNull()][string]$Content)

    if ([string]::IsNullOrWhiteSpace($Content)) {
        return $null
    }

    try {
        if ($PSVersionTable.PSVersion.Major -ge 6) {
            return $Content | ConvertFrom-Json -Depth 100
        }

        return $Content | ConvertFrom-Json
    } catch {
        return $Content
    }
}

function Get-ErrorBody {
    param([System.Management.Automation.ErrorRecord]$ErrorRecord)

    try {
        $response = $ErrorRecord.Exception.Response
        if ($null -eq $response) {
            return $ErrorRecord.Exception.Message
        }

        $stream = $response.GetResponseStream()
        if ($null -eq $stream) {
            return $ErrorRecord.Exception.Message
        }

        $reader = New-Object System.IO.StreamReader($stream)
        try {
            return $reader.ReadToEnd()
        } finally {
            $reader.Dispose()
        }
    } catch {
        return $ErrorRecord.Exception.Message
    }
}

function Get-ResponseValue {
    param(
        $Response,
        [string[]]$Candidates
    )

    foreach ($candidate in $Candidates) {
        $current = $Response
        foreach ($segment in ($candidate -split '\.')) {
            if ($null -eq $current) {
                break
            }

            if ($current -is [string]) {
                $current = $null
                break
            }

            if ($current -is [System.Collections.IDictionary]) {
                if ($current.Contains($segment)) {
                    $current = $current[$segment]
                } else {
                    $current = $null
                    break
                }
            } elseif ($current.PSObject.Properties.Name -contains $segment) {
                $current = $current.$segment
            } else {
                $current = $null
                break
            }
        }

        if ($null -ne $current -and -not [string]::IsNullOrWhiteSpace([string]$current)) {
            return [string]$current
        }
    }

    return $null
}

function Get-PamConfig {
    param([string]$Path)

    $config = [ordered]@{}

    if (Test-Path -LiteralPath $Path) {
        foreach ($rawLine in Get-Content -LiteralPath $Path -Encoding UTF8) {
            $line = $rawLine.TrimEnd("`r")
            if ($line -match '^\s*$' -or $line -match '^\s*[#;]') {
                continue
            }

            $index = $line.IndexOf('=')
            if ($index -lt 1) {
                continue
            }

            $key = $line.Substring(0, $index).Trim()
            $value = $line.Substring($index + 1).Trim()
            if ($value -match '^(.*?\S)\s+[;#].*$') {
                $value = $Matches[1]
            }

            switch ($key) {
                'HOME_BASE_URL' { $config[$key] = $value }
                'CLIENT_ID' { $config[$key] = $value }
                'CLIENT_SECRET' { $config[$key] = $value }
                'AIRPORT_CODE' { $config[$key] = $value }
                'APP_NAME' { $config[$key] = $value }
                'MODULE_NAME' { $config[$key] = $value }
                'VERSION_NUMBER' { $config[$key] = $value }
                'ZIP_FILE_PATH' { $config[$key] = $value }
                'ACTION_TYPE' { $config[$key] = $value }
                'TIMEOUT' { $config[$key] = $value }
                'LOG_NAME' { $config[$key] = $value }
            }
        }
    } else {
        Write-WarnLog "Config file not found: $Path. Defaults will be used."
    }

    $defaults = [ordered]@{
        HOME_BASE_URL = 'https://pam.home.com'
        CLIENT_ID = 'your_client_id'
        CLIENT_SECRET = 'your_client_secret'
        AIRPORT_CODE = 'HET'
        APP_NAME = 'PAM'
        MODULE_NAME = 'Node'
        VERSION_NUMBER = '2.0.5'
        ZIP_FILE_PATH = 'C:\path\to\pam-2.0.5.zip'
        ACTION_TYPE = 'FULL'
        TIMEOUT = '120'
        LOG_NAME = 'app.log'
    }

    foreach ($name in $defaults.Keys) {
        if (-not $config.Contains($name) -or [string]::IsNullOrWhiteSpace([string]$config[$name])) {
            $config[$name] = $defaults[$name]
        }
    }

    return [pscustomobject]$config
}

function Join-RequestPairs {
    param([System.Collections.IDictionary]$Values)

    $pairs = foreach ($key in $Values.Keys) {
        $encodedValue = [System.Uri]::EscapeDataString([string]$Values[$key])
        '{0}={1}' -f $key, $encodedValue
    }

    return ($pairs -join '&')
}

function Test-ZipFile {
    param($Config)

    if (-not (Test-Path -LiteralPath $Config.ZIP_FILE_PATH)) {
        throw "Package file not found: $($Config.ZIP_FILE_PATH)"
    }
}

function Invoke-PamWebRequest {
    param(
        [ValidateSet('GET', 'POST', 'PUT')]
        [string]$Method,
        [string]$Url,
        [string]$Token,
        [hashtable]$Headers = @{},
        [AllowNull()]$Body = $null,
        [string]$ContentType = '',
        [string]$OutFile = ''
    )

    $allHeaders = @{}
    if ($Token) {
        $allHeaders['Authorization'] = "Bearer $Token"
    }
    foreach ($key in $Headers.Keys) {
        $allHeaders[$key] = $Headers[$key]
    }

    $params = @{
        Uri = $Url
        Method = $Method
        Headers = $allHeaders
        ErrorAction = 'Stop'
    }

    if ($PSVersionTable.PSVersion.Major -lt 6) {
        $params['UseBasicParsing'] = $true
    }

    if ($PSBoundParameters.ContainsKey('Body') -and $null -ne $Body -and "$Body" -ne '') {
        $params['Body'] = $Body
    }

    if ($ContentType) {
        $params['ContentType'] = $ContentType
    }

    if ($OutFile) {
        $params['OutFile'] = $OutFile
    }

    try {
        $response = Invoke-WebRequest @params
        if ($OutFile) {
            return $OutFile
        }
        return Convert-ResponseContent $response.Content
    } catch {
        $body = Get-ErrorBody $_
        throw "Request failed [$Method] $Url`n$body"
    }
}

function Invoke-PamMultipartUpload {
    param(
        [string]$Url,
        [string]$Token,
        [string]$FilePath,
        [hashtable]$Fields
    )

    Add-Type -AssemblyName System.Net.Http

    $client = [System.Net.Http.HttpClient]::new()
    try {
        $client.DefaultRequestHeaders.Authorization =
            [System.Net.Http.Headers.AuthenticationHeaderValue]::new('Bearer', $Token)

        $content = [System.Net.Http.MultipartFormDataContent]::new()
        foreach ($entry in $Fields.GetEnumerator()) {
            $stringContent = [System.Net.Http.StringContent]::new([string]$entry.Value, [System.Text.Encoding]::UTF8)
            $content.Add($stringContent, $entry.Key)
        }

        $stream = [System.IO.File]::OpenRead($FilePath)
        try {
            $fileContent = [System.Net.Http.StreamContent]::new($stream)
            $fileContent.Headers.ContentType =
                [System.Net.Http.Headers.MediaTypeHeaderValue]::Parse('application/octet-stream')
            $content.Add($fileContent, 'file', [System.IO.Path]::GetFileName($FilePath))

            $response = $client.PostAsync($Url, $content).GetAwaiter().GetResult()
            $body = $response.Content.ReadAsStringAsync().GetAwaiter().GetResult()
            if (-not $response.IsSuccessStatusCode) {
                throw "Upload failed [HTTP $([int]$response.StatusCode)]`n$body"
            }

            return Convert-ResponseContent $body
        } finally {
            $stream.Dispose()
        }
    } finally {
        $client.Dispose()
    }
}

function Get-Token {
    param($Config)

    Write-Info 'Getting token...'
    $body = Join-RequestPairs ([ordered]@{
        grant_type = 'client_credentials'
        client_id = $Config.CLIENT_ID
        client_secret = $Config.CLIENT_SECRET
    })
    $response = Invoke-PamWebRequest -Method POST -Url "$($Config.HOME_BASE_URL)/oauth/token" -Token '' -Body $body -ContentType 'application/x-www-form-urlencoded'
    $token = Get-ResponseValue -Response $response -Candidates @('access_token')
    if (-not $token) {
        throw "Invalid token response: $response"
    }
    return $token
}

function New-VersionRecord {
    param($Config, [string]$Token)

    Write-Info 'Step 2.1: create version record'
    $body = Join-RequestPairs ([ordered]@{
        versionNumber = $Config.VERSION_NUMBER
        applicationName = $Config.APP_NAME
        moduleName = $Config.MODULE_NAME
        description = 'Auto Deploy'
    })
    [void](Invoke-PamWebRequest -Method POST -Url "$($Config.HOME_BASE_URL)/api/version/upgrade" -Token $Token -Body $body -ContentType 'application/x-www-form-urlencoded')
}

function Upload-Package {
    param($Config, [string]$Token)

    Write-Info 'Step 2.2: upload package'
    $response = Invoke-PamMultipartUpload -Url "$($Config.HOME_BASE_URL)/api/version/upgrade/upload" -Token $Token -FilePath $Config.ZIP_FILE_PATH -Fields @{
        applicationName = $Config.APP_NAME
        moduleName = $Config.MODULE_NAME
        versionNumber = $Config.VERSION_NUMBER
    }

    $hashCode = Get-ResponseValue -Response $response -Candidates @('hashCode', 'data.hashCode')
    if (-not $hashCode -and $response -is [string]) {
        $hashCode = $response.Trim()
    }
    if (-not $hashCode) {
        throw "Unable to parse hashCode from upload response: $response"
    }

    return $hashCode
}

function Publish-Version {
    param($Config, [string]$Token, [string]$HashCode)

    Write-Info 'Step 2.3: publish version'
    $payload = @{
        airportCodesWhite = @($Config.AIRPORT_CODE)
        hashCode = $HashCode
        state = 'RELEASE'
    } | ConvertTo-Json -Depth 5

    $query = Join-RequestPairs ([ordered]@{
        versionNumber = $Config.VERSION_NUMBER
        applicationName = $Config.APP_NAME
        moduleName = $Config.MODULE_NAME
    })

    [void](Invoke-PamWebRequest -Method PUT -Url "$($Config.HOME_BASE_URL)/api/version/upgrade/profile?$query" -Token $Token -Body $payload -ContentType 'application/json')
}

function Get-NodeUrl {
    param($Config, [string]$Token)

    Write-Info 'Step 3.1: resolve node url'
    $response = Invoke-PamWebRequest -Method GET -Url "$($Config.HOME_BASE_URL)/api/mcp/airport/target-node?airportCode=$($Config.AIRPORT_CODE)" -Token $Token

    if ($response -is [System.Collections.IDictionary]) {
        return [string]($response.Keys | Select-Object -First 1)
    }

    $propertyNames = @($response.PSObject.Properties.Name)
    if ($propertyNames.Count -gt 0) {
        return [string]$propertyNames[0]
    }

    throw "Unable to resolve node url: $response"
}

function Get-OnlineIps {
    param($Config, [string]$Token, [string]$NodeUrl)

    Write-Info 'Step 3.2: query online IP list'
    $query = Join-RequestPairs ([ordered]@{
        applicationName = $Config.APP_NAME
        moduleName = $Config.MODULE_NAME
        airportCode = $Config.AIRPORT_CODE
    })

    $response = Invoke-PamWebRequest -Method GET -Url "$($Config.HOME_BASE_URL)/node_proxy/$($Config.AIRPORT_CODE)/api/mcp/version/upgrade/ips?$query" -Token $Token -Headers @{
        'Target-Node' = $NodeUrl
    }

    $ips = @()
    if ($response -is [System.Array]) {
        $ips = @($response | ForEach-Object { [string]$_ } | Where-Object { $_ })
    } elseif ($response -is [System.Collections.IEnumerable] -and -not ($response -is [string])) {
        $ips = @($response | ForEach-Object { [string]$_ } | Where-Object { $_ })
    }

    if ($ips.Count -eq 0) {
        throw "No online workstation matched the module. Raw response: $response"
    }

    return $ips
}

function Wait-DownloadProgress {
    param($Config, [string]$Token, [string]$NodeUrl)

    $query = Join-RequestPairs ([ordered]@{
        applicationName = $Config.APP_NAME
        moduleName = $Config.MODULE_NAME
        airportCode = $Config.AIRPORT_CODE
    })
    $progressUrl = "$($Config.HOME_BASE_URL)/node_proxy/$($Config.AIRPORT_CODE)/api/mcp/version/upgrade/download-cloud/progress?$query"

    for ($attempt = 0; $attempt -lt 60; $attempt++) {
        $response = Invoke-PamWebRequest -Method GET -Url $progressUrl -Token $Token -Headers @{
            'Target-Node' = $NodeUrl
        }

        $status = Get-ResponseValue -Response $response -Candidates @('status')
        $successFlag = Get-ResponseValue -Response $response -Candidates @('success')
        if ($status -eq 'completed' -or $successFlag -eq 'true') {
            return
        }

        $message = Get-ResponseValue -Response $response -Candidates @('message')
        if ($message -and $message -match '(?i)fail|error') {
            throw "Node download failed: $message"
        }

        Start-Sleep -Seconds 2
    }

    throw 'Node download timed out.'
}

function Download-CloudToNode {
    param($Config, [string]$Token, [string]$NodeUrl)

    Write-Info 'Step 3.3: download package to node'
    $query = Join-RequestPairs ([ordered]@{
        versionNumber = $Config.VERSION_NUMBER
        applicationName = $Config.APP_NAME
        moduleName = $Config.MODULE_NAME
        timeOut = $Config.TIMEOUT
    })

    [void](Invoke-PamWebRequest -Method GET -Url "$($Config.HOME_BASE_URL)/node_proxy/$($Config.AIRPORT_CODE)/api/mcp/version/upgrade/download-cloud?$query" -Token $Token -Headers @{
        'Target-Node' = $NodeUrl
        'airport-code' = $Config.AIRPORT_CODE
    })

    Wait-DownloadProgress -Config $Config -Token $Token -NodeUrl $NodeUrl
}

function Invoke-UpgradeRequest {
    param($Config, [string]$Token, [string]$NodeUrl, [string]$Ip)

    $body = Join-RequestPairs ([ordered]@{
        airportCode = $Config.AIRPORT_CODE
        targetIp = $Ip
        applicationName = $Config.APP_NAME
        moduleName = $Config.MODULE_NAME
        versionNumber = $Config.VERSION_NUMBER
        action = $Config.ACTION_TYPE
        autoStart = 'false'
        timeOut = $Config.TIMEOUT
    })

    Invoke-PamWebRequest -Method POST -Url "$($Config.HOME_BASE_URL)/node_proxy/$($Config.AIRPORT_CODE)/api/mcp/version/upgrade" -Token $Token -Headers @{
        'Target-Node' = $NodeUrl
    } -Body $body -ContentType 'application/x-www-form-urlencoded'
}

function Start-Application {
    param($Config, [string]$Token, [string]$NodeUrl, [string]$Ip)

    $body = Join-RequestPairs ([ordered]@{
        airportCode = $Config.AIRPORT_CODE
        targetIp = $Ip
        applicationName = $Config.APP_NAME
        moduleName = $Config.MODULE_NAME
        runstart = 'true'
    })

    [void](Invoke-PamWebRequest -Method POST -Url "$($Config.HOME_BASE_URL)/node_proxy/$($Config.AIRPORT_CODE)/api/mcp/version/upgrade/start-stop" -Token $Token -Headers @{
        'Target-Node' = $NodeUrl
    } -Body $body -ContentType 'application/x-www-form-urlencoded')
}

function Stop-Application {
    param($Config, [string]$Token, [string]$NodeUrl, [string]$Ip)

    $body = Join-RequestPairs ([ordered]@{
        airportCode = $Config.AIRPORT_CODE
        targetIp = $Ip
        applicationName = $Config.APP_NAME
        moduleName = $Config.MODULE_NAME
        runstart = 'false'
    })

    [void](Invoke-PamWebRequest -Method POST -Url "$($Config.HOME_BASE_URL)/node_proxy/$($Config.AIRPORT_CODE)/api/mcp/version/upgrade/start-stop" -Token $Token -Headers @{
        'Target-Node' = $NodeUrl
    } -Body $body -ContentType 'application/x-www-form-urlencoded')
}

function Verify-Ip {
    param($Config, [string]$Token, [string]$NodeUrl, [string]$Ip)

    $query = Join-RequestPairs ([ordered]@{
        applicationName = $Config.APP_NAME
        moduleName = $Config.MODULE_NAME
        airportCode = $Config.AIRPORT_CODE
        targetIp = $Ip
    })

    Invoke-PamWebRequest -Method GET -Url "$($Config.HOME_BASE_URL)/node_proxy/$($Config.AIRPORT_CODE)/api/mcp/version/upgrade/verify?$query" -Token $Token -Headers @{
        'Target-Node' = $NodeUrl
    }
}

function Download-DeployLog {
    param($Config, [string]$Token, [string]$NodeUrl, [string]$Ip)

    $logsDir = Join-Path $PSScriptRoot 'logs'
    if (-not (Test-Path -LiteralPath $logsDir)) {
        $null = New-Item -ItemType Directory -Path $logsDir
    }

    $logFile = Join-Path $logsDir ("deploy_{0}.log" -f $Ip)
    $errorFile = Join-Path $logsDir ("error_{0}.log" -f $Ip)
    $query = Join-RequestPairs ([ordered]@{
        applicationName = $Config.APP_NAME
        moduleName = $Config.MODULE_NAME
        airportCode = $Config.AIRPORT_CODE
        targetIp = $Ip
        logName = $Config.LOG_NAME
    })

    try {
        [void](Invoke-PamWebRequest -Method GET -Url "$($Config.HOME_BASE_URL)/node_proxy/$($Config.AIRPORT_CODE)/api/mcp/version/upgrade/log-download?$query" -Token $Token -Headers @{
            'Target-Node' = $NodeUrl
        } -OutFile $logFile)

        if ((Get-Item -LiteralPath $logFile).Length -gt 0) {
            Get-Content -LiteralPath $logFile -Tail 5 | Set-Content -LiteralPath "$logFile.summary"
        } else {
            'Log content empty or no data' | Set-Content -LiteralPath "$logFile.summary"
        }
    } catch {
        Get-ErrorBody $_ | Set-Content -LiteralPath $errorFile
        "Log download failed. See $errorFile" | Set-Content -LiteralPath $logFile
        'Log download failed' | Set-Content -LiteralPath "$logFile.summary"
    }

    return $logFile
}

function Invoke-Rollback {
    param($Config, [string]$Token, [string]$NodeUrl, [string]$Ip, [bool]$StopFirst)

    if ($StopFirst) {
        try {
            Stop-Application -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip
        } catch {
        }
    }

    try {
        $body = Join-RequestPairs ([ordered]@{
            airportCode = $Config.AIRPORT_CODE
            targetIp = $Ip
            applicationName = $Config.APP_NAME
            moduleName = $Config.MODULE_NAME
            timeOut = $Config.TIMEOUT
        })
        $response = Invoke-PamWebRequest -Method POST -Url "$($Config.HOME_BASE_URL)/node_proxy/$($Config.AIRPORT_CODE)/api/mcp/version/upgrade/rollback" -Token $Token -Headers @{
            'Target-Node' = $NodeUrl
        } -Body $body -ContentType 'application/x-www-form-urlencoded'

        $rollbackSuccess = Get-ResponseValue -Response $response -Candidates @('success')
        if ($rollbackSuccess -and $rollbackSuccess -ne 'true') {
            return 'ROLLBACK_FAILED'
        }
    } catch {
        return 'ROLLBACK_REQUEST_FAILED'
    }

    try {
        $verify = Verify-Ip -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip
        if ((Get-ResponseValue -Response $verify -Candidates @('success')) -eq 'true') {
            return 'ROLLBACK_SUCCESS'
        }
        return 'ROLLBACK_VERIFY_FAILED'
    } catch {
        return 'ROLLBACK_VERIFY_FAILED'
    }
}

function Invoke-IpDeploy {
    param(
        $Config,
        [string]$Token,
        [string]$NodeUrl,
        [string]$Ip
    )

    Write-Info "Processing IP: $Ip"

    try {
        $upgrade = Invoke-UpgradeRequest -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip
    } catch {
        $logFile = Download-DeployLog -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip
        return [pscustomobject]@{
            Ip = $Ip
            Status = 'FAILED'
            Stage = 'UPGRADE'
            Message = 'Upgrade request failed'
            Rollback = 'ROLLBACK_NOT_RUN'
            LogFile = $logFile
        }
    }

    if ((Get-ResponseValue -Response $upgrade -Candidates @('success')) -ne 'true') {
        $rollback = Invoke-Rollback -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip -StopFirst:$false
        $logFile = Download-DeployLog -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip
        $message = Get-ResponseValue -Response $upgrade -Candidates @('message')
        if (-not $message) { $message = 'Upgrade failed' }
        return [pscustomobject]@{
            Ip = $Ip
            Status = 'FAILED'
            Stage = 'UPGRADE'
            Message = $message
            Rollback = $rollback
            LogFile = $logFile
        }
    }

    try {
        Start-Application -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip
    } catch {
        $rollback = Invoke-Rollback -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip -StopFirst:$true
        $logFile = Download-DeployLog -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip
        return [pscustomobject]@{
            Ip = $Ip
            Status = 'FAILED'
            Stage = 'START'
            Message = 'Application start failed'
            Rollback = $rollback
            LogFile = $logFile
        }
    }

    try {
        $verify = Verify-Ip -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip
    } catch {
        $rollback = Invoke-Rollback -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip -StopFirst:$true
        $logFile = Download-DeployLog -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip
        return [pscustomobject]@{
            Ip = $Ip
            Status = 'FAILED'
            Stage = 'VERIFY'
            Message = 'Health check request failed'
            Rollback = $rollback
            LogFile = $logFile
        }
    }

    if ((Get-ResponseValue -Response $verify -Candidates @('success')) -eq 'true') {
        $logFile = Download-DeployLog -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip
        return [pscustomobject]@{
            Ip = $Ip
            Status = 'SUCCESS'
            Stage = '-'
            Message = '-'
            Rollback = '-'
            LogFile = $logFile
        }
    }

    $rollback = Invoke-Rollback -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip -StopFirst:$true
    $logFile = Download-DeployLog -Config $Config -Token $Token -NodeUrl $NodeUrl -Ip $Ip
    $message = Get-ResponseValue -Response $verify -Candidates @('message')
    if (-not $message) { $message = 'Health check failed' }
    return [pscustomobject]@{
        Ip = $Ip
        Status = 'FAILED'
        Stage = 'VERIFY'
        Message = $message
        Rollback = $rollback
        LogFile = $logFile
    }
}

function Write-DeployReport {
    param(
        $Config,
        [System.Collections.Generic.List[object]]$Results,
        [int]$TotalCount
    )

    $successCount = @($Results | Where-Object { $_.Status -eq 'SUCCESS' }).Count
    $failCount = @($Results | Where-Object { $_.Status -ne 'SUCCESS' }).Count

    Write-Host ''
    Write-Host '====================== DEPLOY REPORT ======================'
    Write-Host 'Mode: Batch/PowerShell'
    Write-Host "Airport: $($Config.AIRPORT_CODE)"
    Write-Host "Application: $($Config.APP_NAME)"
    Write-Host "Module: $($Config.MODULE_NAME)"
    Write-Host "Version: $($Config.VERSION_NUMBER)"
    Write-Host "Total: $TotalCount"
    Write-Host "Success: $successCount"
    Write-Host "Failed: $failCount"
    Write-Host ''
    Write-Host ('{0,-18} {1,-8} {2,-12} {3,-22} {4}' -f 'IP', 'STATUS', 'STAGE', 'ROLLBACK', 'LOG')
    foreach ($item in $Results) {
        Write-Host ('{0,-18} {1,-8} {2,-12} {3,-22} {4}' -f $item.Ip, $item.Status, $item.Stage, $item.Rollback, $item.LogFile)
        if ($item.Status -ne 'SUCCESS') {
            Write-Host ("  Reason: {0}" -f $item.Message)
        }
    }
}

function Invoke-PamDeploy {
    param([string]$ConfigPath)

    $config = Get-PamConfig -Path $ConfigPath
    Test-ZipFile -Config $config

    Write-Info "Deploy start: airport=$($config.AIRPORT_CODE), version=$($config.VERSION_NUMBER), module=$($config.APP_NAME)/$($config.MODULE_NAME)"

    $token = Get-Token -Config $config
    New-VersionRecord -Config $config -Token $token
    $hashCode = Upload-Package -Config $config -Token $token
    Publish-Version -Config $config -Token $token -HashCode $hashCode
    $nodeUrl = Get-NodeUrl -Config $config -Token $token
    $ips = Get-OnlineIps -Config $config -Token $token -NodeUrl $nodeUrl
    Download-CloudToNode -Config $config -Token $token -NodeUrl $nodeUrl

    $results = [System.Collections.Generic.List[object]]::new()
    foreach ($ip in $ips) {
        $results.Add((Invoke-IpDeploy -Config $config -Token $token -NodeUrl $nodeUrl -Ip $ip))
    }

    Write-DeployReport -Config $config -Results $results -TotalCount $ips.Count
}

if ($Help) {
    Show-DeployUsage
    exit 0
}

if ($MyInvocation.InvocationName -ne '.') {
    try {
        Invoke-PamDeploy -ConfigPath $ConfigPath
    } catch {
        Write-ErrLog $_
        exit 1
    }
}