param(
    [string]$ImageNamespace = $(if ($env:IMAGE_NAMESPACE) { $env:IMAGE_NAMESPACE } else { "emp-test" }),
    [string]$ImageTag = $(if ($env:IMAGE_TAG) { $env:IMAGE_TAG } else { Get-Date -Format "yyyyMMddHHmmss" }),
    [string]$NpmRegistry = $(if ($env:NPM_REGISTRY) { $env:NPM_REGISTRY } else { "https://registry.npmjs.org" }),
    [string]$EmpRoot = $(if ($env:EMP_ROOT) { $env:EMP_ROOT } else { "" }),
    [switch]$SkipBuild,
    [switch]$NoMiddlewareImages
)

$ErrorActionPreference = "Stop"

# Local package script. Build images locally, export them, then run on server only with docker load + compose up.
$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
$RootDir = $null
$DistDir = Join-Path $ScriptDir "dist"
$BuildContextDir = Join-Path $ScriptDir ".build-context"
$PackageName = "emp-test-runtime-$ImageTag"
$PackageDir = Join-Path $DistDir $PackageName
$PackageArchive = Join-Path $DistDir "$PackageName.tar.gz"

$JavaModules = @("emp_gateway", "emp_auth", "emp_monitor", "emp_data")
$AppImages = @(
    "$ImageNamespace/emp-gateway:$ImageTag",
    "$ImageNamespace/emp-gateway:latest",
    "$ImageNamespace/emp-auth:$ImageTag",
    "$ImageNamespace/emp-auth:latest",
    "$ImageNamespace/emp-monitor:$ImageTag",
    "$ImageNamespace/emp-monitor:latest",
    "$ImageNamespace/emp-data:$ImageTag",
    "$ImageNamespace/emp-data:latest",
    "$ImageNamespace/emp-pdf:$ImageTag",
    "$ImageNamespace/emp-pdf:latest",
    "$ImageNamespace/emp-ws:$ImageTag",
    "$ImageNamespace/emp-ws:latest",
    "$ImageNamespace/emp-admin:$ImageTag",
    "$ImageNamespace/emp-admin:latest"
)

$MiddlewareImages = @(
    $(if ($env:MYSQL_IMAGE) { $env:MYSQL_IMAGE } else { "mysql:8.0" }),
    $(if ($env:REDIS_IMAGE) { $env:REDIS_IMAGE } else { "redis:7-alpine" }),
    $(if ($env:KAFKA_IMAGE) { $env:KAFKA_IMAGE } else { "bitnami/kafka:3.7.0" }),
    $(if ($env:TDENGINE_IMAGE) { $env:TDENGINE_IMAGE } else { "tdengine/tdengine:3.3.6.0" }),
    $(if ($env:NACOS_IMAGE) { $env:NACOS_IMAGE } else { "nacos/nacos-server:v2.3.2-slim" })
)

function Write-Log {
    param([string]$Message)
    Write-Host "[$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')] $Message"
}

function Add-KnownToolPaths {
    $KnownDirs = @(
        "C:\Program Files\Docker\Docker\resources\bin",
        "C:\Program Files\Docker\Docker",
        "$env:ProgramFiles\Docker\Docker\resources\bin"
    )

    foreach ($Dir in $KnownDirs) {
        if ($Dir -and (Test-Path $Dir) -and (($env:Path -split ';') -notcontains $Dir)) {
            $env:Path = "$Dir;$env:Path"
        }
    }
}

function Assert-Command {
    param([string]$Name)
    if (-not (Get-Command $Name -ErrorAction SilentlyContinue)) {
        throw "Missing command: $Name"
    }
}

function Assert-DockerDaemon {
    & docker info *> $null
    if ($LASTEXITCODE -ne 0) {
        throw "Docker daemon is not running. Start Docker Desktop and wait until it is ready, then rerun this script."
    }
}

function Test-EmpRoot {
    param([string]$Path)
    return (Test-Path (Join-Path $Path "emp_server")) `
        -and (Test-Path (Join-Path $Path "emp_admin")) `
        -and (Test-Path (Join-Path $Path "emp_ws"))
}

function Resolve-EmpRoot {
    if ($EmpRoot) {
        $Resolved = (Resolve-Path $EmpRoot).Path
        if (-not (Test-EmpRoot $Resolved)) {
            throw "EMP_ROOT is invalid: $EmpRoot"
        }
        return $Resolved
    }

    $Candidates = @(
        (Join-Path $ScriptDir "..\.."),
        (Join-Path $ScriptDir "..\..\emp"),
        (Join-Path $ScriptDir ".."),
        (Get-Location).Path
    )

    foreach ($Candidate in $Candidates) {
        if (Test-Path $Candidate) {
            $Resolved = (Resolve-Path $Candidate).Path
            if (Test-EmpRoot $Resolved) {
                return $Resolved
            }
        }
    }

    throw "Cannot find EMP root. Set EMP_ROOT=/path/to/emp where emp_server, emp_admin and emp_ws exist."
}

function Invoke-Step {
    param(
        [string]$WorkingDirectory,
        [string]$FilePath,
        [string[]]$Arguments
    )
    Push-Location $WorkingDirectory
    try {
        & $FilePath @Arguments
        if ($LASTEXITCODE -ne 0) {
            throw "$FilePath failed, exit code: $LASTEXITCODE"
        }
    } finally {
        Pop-Location
    }
}

function Build-JavaImages {
    $ServerDir = Join-Path $RootDir "emp_server"
    Write-Log "Build backend jars"
    Invoke-Step $ServerDir "mvn" @("package", "-DskipTests", "-B", "-pl", ($JavaModules -join ","), "-am")

    foreach ($Module in $JavaModules) {
        $TargetDir = Join-Path $ServerDir "$Module\target"
        $Jar = Get-ChildItem $TargetDir -Filter "*.jar" |
            Where-Object { $_.Name -ne "app.jar" -and $_.Name -notlike "*original*" } |
            Select-Object -First 1
        if (-not $Jar) {
            throw "Jar not found for $Module"
        }
        Copy-Item $Jar.FullName (Join-Path $TargetDir "app.jar") -Force
    }

    Write-Log "Build backend images"
    Invoke-Step $ServerDir "docker" @("build", "-f", "Dockerfile.service", "--build-arg", "MODULE=emp_gateway", "-t", "$ImageNamespace/emp-gateway:$ImageTag", "-t", "$ImageNamespace/emp-gateway:latest", ".")
    Invoke-Step $ServerDir "docker" @("build", "-f", "Dockerfile.service", "--build-arg", "MODULE=emp_auth", "-t", "$ImageNamespace/emp-auth:$ImageTag", "-t", "$ImageNamespace/emp-auth:latest", ".")
    Invoke-Step $ServerDir "docker" @("build", "-f", "Dockerfile.service", "--build-arg", "MODULE=emp_monitor", "-t", "$ImageNamespace/emp-monitor:$ImageTag", "-t", "$ImageNamespace/emp-monitor:latest", ".")
    Invoke-Step $ServerDir "docker" @("build", "-f", "Dockerfile.service", "--build-arg", "MODULE=emp_data", "-t", "$ImageNamespace/emp-data:$ImageTag", "-t", "$ImageNamespace/emp-data:latest", ".")

    Write-Log "Build PDF image"
    Invoke-Step $ServerDir "docker" @("build", "-f", "emp_pdf/Dockerfile", "-t", "$ImageNamespace/emp-pdf:$ImageTag", "-t", "$ImageNamespace/emp-pdf:latest", "emp_pdf")
}

function Build-WsImage {
    Write-Log "Build WS/simulator image"
    $Dockerfile = Join-Path $ScriptDir "dockerfiles\emp-ws.Dockerfile"
    Invoke-Step $RootDir "docker" @(
        "build",
        "-f", $Dockerfile,
        "--build-arg", "NPM_REGISTRY=$NpmRegistry",
        "-t", "$ImageNamespace/emp-ws:$ImageTag",
        "-t", "$ImageNamespace/emp-ws:latest",
        "."
    )
}

function Build-AdminImage {
    $AdminDir = Join-Path $RootDir "emp_admin"
    Write-Log "Build frontend dist"
    Invoke-Step $AdminDir "pnpm" @("install", "--frozen-lockfile")
    Invoke-Step $AdminDir "pnpm" @("run", "build:shunfeng")

    Write-Log "Prepare frontend image context"
    $ContextDir = Join-Path $BuildContextDir "emp-admin"
    if (Test-Path $ContextDir) {
        Remove-Item $ContextDir -Recurse -Force
    }
    New-Item -ItemType Directory -Force $ContextDir | Out-Null
    Copy-Item (Join-Path $AdminDir "dist") (Join-Path $ContextDir "dist") -Recurse -Force
    Copy-Item (Join-Path $ScriptDir "nginx\admin.conf") (Join-Path $ContextDir "admin.conf") -Force

    Write-Log "Build frontend image"
    $Dockerfile = Join-Path $ScriptDir "dockerfiles\emp-admin.Dockerfile"
    Invoke-Step $ContextDir "docker" @(
        "build",
        "-f", $Dockerfile,
        "-t", "$ImageNamespace/emp-admin:$ImageTag",
        "-t", "$ImageNamespace/emp-admin:latest",
        "."
    )
}

function Prepare-Package {
    if (Test-Path $PackageDir) {
        Remove-Item $PackageDir -Recurse -Force
    }
    New-Item -ItemType Directory -Force $PackageDir | Out-Null

    $ComposeSource = Join-Path $ScriptDir "docker-compose.runtime.yml"
    $EnvSource = Join-Path $ScriptDir ".env.example"
    $TestComposeSource = Join-Path $ScriptDir "test\docker-compose.yml"
    $TestEnvSource = Join-Path $ScriptDir "test\env.txt"
    if (Test-Path $TestComposeSource) {
        $ComposeSource = $TestComposeSource
    }
    if (Test-Path $TestEnvSource) {
        $EnvSource = $TestEnvSource
    }

    Copy-Item $ComposeSource (Join-Path $PackageDir "docker-compose.yml") -Force
    Copy-Item $EnvSource (Join-Path $PackageDir ".env.example") -Force
    Copy-Item (Join-Path $ScriptDir "install.sh") (Join-Path $PackageDir "install.sh") -Force
    Copy-Item (Join-Path $ScriptDir "README.md") (Join-Path $PackageDir "README.md") -Force
}

function Save-Images {
    $Images = New-Object System.Collections.Generic.List[string]
    foreach ($Image in $AppImages) {
        $Images.Add($Image)
    }

    if (-not $NoMiddlewareImages) {
        Write-Log "Pull middleware images"
        foreach ($Image in $MiddlewareImages) {
            Invoke-Step $RootDir "docker" @("pull", $Image)
            $Images.Add($Image)
        }
    }

    Write-Log "Save images"
    Invoke-Step $RootDir "docker" @(@("save", "-o", (Join-Path $PackageDir "images.tar")) + $Images.ToArray())
}

function Archive-Package {
    New-Item -ItemType Directory -Force $DistDir | Out-Null
    if (Test-Path $PackageArchive) {
        Remove-Item $PackageArchive -Force
    }
    Invoke-Step $DistDir "tar" @("-czf", $PackageArchive, $PackageName)
    Write-Log "Package created: $PackageArchive"
}

Add-KnownToolPaths
Assert-Command "docker"
Assert-DockerDaemon
Assert-Command "tar"

$RootDir = Resolve-EmpRoot
Write-Log "EMP root: $RootDir"
Write-Log "Deploy root: $ScriptDir"

if (-not $SkipBuild) {
    Assert-Command "mvn"
    Assert-Command "pnpm"
    Build-JavaImages
    Build-WsImage
    Build-AdminImage
} else {
    Write-Log "Skip build, package existing local images only"
}

Prepare-Package
Save-Images
Archive-Package