build.ps1

# build.ps1 - DevOps Tools Installer (WinUI 3 + .NET 8)
#
# Usage:
#   .\build.ps1                    - Release build (folder output)
#   .\build.ps1 -Configuration Debug
#   .\build.ps1 -SingleFile        - Produces a merged .exe
#   .\build.ps1 -Run               - Build then launch
#   .\build.ps1 -Clean             - Delete all build artifacts

param(
    [ValidateSet('Debug', 'Release')]
    [string]$Configuration = 'Release',
    [switch]$SingleFile,
    [switch]$Setup,
    [switch]$Msi,
    [switch]$Msix,
    [switch]$Run,
    [switch]$Clean
)

$ErrorActionPreference = 'Stop'

$root    = Split-Path -Parent $MyInvocation.MyCommand.Path
$project = Join-Path $root 'src\DevOpsToolsInstaller\DevOpsToolsInstaller.csproj'
$pubDir  = Join-Path $root "src\DevOpsToolsInstaller\bin\x64\$Configuration\net8.0-windows10.0.26100.0\win-x64\publish"
$exe     = Join-Path $pubDir 'DevOpsToolsInstaller.exe'

function Write-Step([string]$msg) {
    Write-Host ""
    Write-Host "  >> $msg" -ForegroundColor Cyan
}

function Write-Ok([string]$msg)   { Write-Host "  [OK]  $msg" -ForegroundColor Green }
function Write-Err([string]$msg)  { Write-Host "  [ERR] $msg" -ForegroundColor Red }
function Write-Warn([string]$msg) { Write-Host "  [!]   $msg" -ForegroundColor Yellow }

function Find-Dotnet {
    if (Get-Command dotnet -ErrorAction SilentlyContinue) { return 'dotnet' }
    $candidates = @(
        'C:\Program Files\dotnet\dotnet.exe',
        'C:\Program Files (x86)\dotnet\dotnet.exe',
        "$env:LOCALAPPDATA\Microsoft\dotnet\dotnet.exe"
    )
    foreach ($c in $candidates) {
        if (Test-Path $c) {
            $env:PATH = ([IO.Path]::GetDirectoryName($c)) + ';' + $env:PATH
            return $c
        }
    }
    return $null
}

function Find-ISCC {
    if (Get-Command ISCC.exe -ErrorAction SilentlyContinue) { return 'ISCC.exe' }
    $candidates = @(
        "$env:LOCALAPPDATA\Programs\Inno Setup 6\ISCC.exe",
        'C:\Program Files (x86)\Inno Setup 6\ISCC.exe',
        'C:\Program Files\Inno Setup 6\ISCC.exe'
    )
    foreach ($c in $candidates) {
        if (Test-Path $c) { return $c }
    }
    return $null
}

function Find-WiX {
    if (Get-Command wix -ErrorAction SilentlyContinue) { return 'wix' }
    $userTools = "$env:USERPROFILE\.dotnet\tools\wix.exe"
    if (Test-Path $userTools) {
        $env:PATH = "$env:USERPROFILE\.dotnet\tools;" + $env:PATH
        return $userTools
    }
    return $null
}

# ---------------------------------------------------------------------------
# Clean
# ---------------------------------------------------------------------------

if ($Clean) {
    Write-Step "Cleaning build artifacts..."
    foreach ($d in @('src\DevOpsToolsInstaller\bin', 'src\DevOpsToolsInstaller\obj')) {
        $full = Join-Path $root $d
        if (Test-Path $full) {
            Remove-Item -Path $full -Recurse -Force
            Write-Ok "Removed $full"
        }
    }
    Write-Host ""
    Write-Host "  Clean complete." -ForegroundColor Green
    exit 0
}

# ---------------------------------------------------------------------------
# Banner
# ---------------------------------------------------------------------------

Write-Host ""
Write-Host "+------------------------------------------------------------------+" -ForegroundColor Cyan
Write-Host "|  DevOps Tools Installer - Build Script (WinUI 3 / .NET 8)       |" -ForegroundColor Cyan
Write-Host "+------------------------------------------------------------------+" -ForegroundColor Cyan
Write-Host ""
Write-Host "  Configuration : $Configuration" -ForegroundColor White
Write-Host "  Single File   : $SingleFile"    -ForegroundColor White
Write-Host "  Setup Wizard  : $Setup"         -ForegroundColor White
Write-Host "  MSI Package   : $Msi"           -ForegroundColor White
Write-Host "  MSIX Package  : $Msix"          -ForegroundColor White
Write-Host "  Project       : $project"        -ForegroundColor Gray
Write-Host ""

# ---------------------------------------------------------------------------
# Prerequisites
# ---------------------------------------------------------------------------

Write-Step "Checking prerequisites..."

$dotnet = Find-Dotnet
if (-not $dotnet) {
    Write-Err ".NET SDK not found."
    Write-Host "  Install .NET 8 SDK: https://dotnet.microsoft.com/download/dotnet/8.0" -ForegroundColor Yellow
    exit 1
}

$dotnetVersion = (& $dotnet --version 2>&1) | Out-String
$dotnetVersion = $dotnetVersion.Trim()
Write-Ok ".NET SDK $dotnetVersion"

$major = [int]($dotnetVersion -split '\.')[0]
if ($major -lt 8) {
    Write-Err ".NET 8.0 or higher required (found $dotnetVersion)"
    exit 1
}

if (-not (Test-Path $project)) {
    Write-Err "Project not found: $project"
    exit 1
}
Write-Ok "Project file found"

$catalogPath = Join-Path $root 'catalog\catalog.json'
if (Test-Path $catalogPath) {
    Write-Ok "catalog.json found"
} else {
    Write-Warn "catalog.json not found at $catalogPath"
}

Write-Ok "Prerequisites passed"

# ---------------------------------------------------------------------------
# Restore
# ---------------------------------------------------------------------------

Write-Step "Restoring NuGet packages..."
$restoreOut = & $dotnet restore $project -r win-x64 2>&1
if ($LASTEXITCODE -ne 0) {
    Write-Err "Restore failed:"
    $restoreOut | ForEach-Object { Write-Host "    $_" -ForegroundColor Red }
    exit 1
}
Write-Ok "Packages restored"

# ---------------------------------------------------------------------------
# Publish
# ---------------------------------------------------------------------------

Write-Step "Publishing ($Configuration, win-x64, self-contained)..."

$publishArgs = [System.Collections.Generic.List[string]]@(
    'publish', $project,
    '-c', $Configuration,
    '-r', 'win-x64',
    '--self-contained', 'true',
    '--no-restore',
    '-p:WindowsAppSDKSelfContained=true',
    '-p:Platform=x64'
)

if ($SingleFile) {
    $publishArgs.Add('-p:PublishSingleFile=true')
    $publishArgs.Add('-p:IncludeNativeLibrariesForSelfExtract=true')
    $publishArgs.Add('-p:EnableCompressionInSingleFile=true')
    Write-Warn "Single-file: Windows App SDK runtime may still extract DLLs on first run"
}

$buildOut = & $dotnet @publishArgs 2>&1
$buildOut | ForEach-Object {
    $line = "$_"
    if ($line -match ' error ') {
        Write-Host "    $line" -ForegroundColor Red
    } elseif ($line -match ' warning ') {
        Write-Host "    $line" -ForegroundColor Yellow
    }
}

if ($LASTEXITCODE -ne 0) {
    Write-Err "Publish failed - see output above."
    exit 1
}

# ---------------------------------------------------------------------------
# Verify output
# ---------------------------------------------------------------------------

Write-Step "Verifying output..."

if (-not (Test-Path $exe)) {
    Write-Err "Expected exe not found: $exe"
    if (Test-Path $pubDir) {
        Write-Warn "Publish dir contents:"
        Get-ChildItem $pubDir | ForEach-Object { Write-Host "    $($_.Name)" -ForegroundColor Gray }
    }
    exit 1
}

$exeSizeBytes = (Get-Item $exe).Length
$exeSizeMB    = [math]::Round($exeSizeBytes / 1MB, 1)
Write-Ok "DevOpsToolsInstaller.exe ($exeSizeMB MB)"

$copiedCatalog = Join-Path $pubDir 'Assets\catalog.json'
if (Test-Path $copiedCatalog) {
    Write-Ok "catalog.json embedded in output"
} else {
    Write-Warn "catalog.json not in output - app will fetch from GitHub at runtime"
}

# ---------------------------------------------------------------------------
# Summary
# ---------------------------------------------------------------------------

Write-Host ""
Write-Host "+------------------------------------------------------------------+" -ForegroundColor Green
Write-Host "|                    BUILD SUCCEEDED!                              |" -ForegroundColor Green
Write-Host "+------------------------------------------------------------------+" -ForegroundColor Green
Write-Host ""
Write-Host "  Exe  : $exe" -ForegroundColor White
Write-Host "  Size : $exeSizeMB MB" -ForegroundColor Gray
Write-Host ""
Write-Host "  Run:" -ForegroundColor Yellow
Write-Host "    $exe" -ForegroundColor White
Write-Host ""

# ---------------------------------------------------------------------------
# MSIX Package for Microsoft Store
# ---------------------------------------------------------------------------

if ($Msix) {
    Write-Step "Building MSIX package for Microsoft Store submission..."

    $msixOutDir = Join-Path (Split-Path -Parent $project) 'bin\MsixPackage'
    if (-not (Test-Path $msixOutDir)) { New-Item -ItemType Directory -Path $msixOutDir | Out-Null }

    $msixArgs = @(
        'publish', $project,
        '-c', $Configuration,
        '-r', 'win-x64',
        '--self-contained', 'true',
        '-p:Platform=x64',
        '-p:BuildMsix=true',
        '-p:WindowsAppSDKSelfContained=true',
        '-p:AppxPackageSigningEnabled=false',
        '-p:GenerateAppxPackageOnBuild=true',
        '-p:AppxBundle=Always',
        '-p:AppxBundlePlatforms=x64',
        "-p:AppxPackageDir=$msixOutDir\"
    )

    Write-Host "  Running dotnet publish with MSIX tooling..." -ForegroundColor Gray
    $msixOut = & $dotnet @msixArgs 2>&1
    $msixOut | ForEach-Object {
        $line = "$_"
        if ($line -match ' error ')   { Write-Host "    $line" -ForegroundColor Red }
        elseif ($line -match ' warning ') { Write-Host "    $line" -ForegroundColor Yellow }
    }

    if ($LASTEXITCODE -eq 0) {
        # Find the produced .msixupload, .msixbundle, or .msix file
        $msixFile = Get-ChildItem -Path $msixOutDir -Include '*.msixupload','*.msixbundle','*.msix' -Recurse |
                    Sort-Object LastWriteTime -Descending | Select-Object -First 1
        if ($msixFile) {
            $sizeMB = [math]::Round($msixFile.Length / 1MB, 1)
            Write-Ok "MSIX package: $($msixFile.FullName) ($sizeMB MB)"
            Write-Host ""
            Write-Host "  Next step: upload '$($msixFile.Name)' to Microsoft Partner Center" -ForegroundColor Yellow
            Write-Host "  Dashboard: https://partner.microsoft.com/dashboard" -ForegroundColor Cyan
        } else {
            Write-Warn "Build succeeded but no .msixupload/.msix file found in $msixOutDir"
            Write-Host "  Contents:" -ForegroundColor Gray
            Get-ChildItem -Recurse $msixOutDir | ForEach-Object { Write-Host "    $($_.FullName)" -ForegroundColor Gray }
        }
    } else {
        Write-Err "MSIX build failed - see output above."
    }
}

# ---------------------------------------------------------------------------
# Setup Wizard (Inno Setup)
# ---------------------------------------------------------------------------

if ($Setup) {
    Write-Step "Building Windows Setup Wizard (Inno Setup)..."
    $iscc = Find-ISCC
    if (-not $iscc) {
        Write-Err "Inno Setup Compiler (ISCC.exe) not found. Install it with: winget install JRSoftware.InnoSetup --scope user"
    } else {
        $issFile = Join-Path $root 'installer\setup.iss'
        $distDir = Join-Path $root 'dist'
        if (-not (Test-Path $distDir)) { New-Item -ItemType Directory -Path $distDir | Out-Null }

        Write-Host "  Compiling with $iscc..." -ForegroundColor Gray
        & $iscc "/DSourceDir=$pubDir" $issFile
        if ($LASTEXITCODE -eq 0) {
            $setupExe = Get-ChildItem -Path $distDir -Filter "*Setup.exe" | Sort-Object LastWriteTime -Descending | Select-Object -First 1
            if ($setupExe) {
                Write-Ok "Setup Wizard generated: $($setupExe.FullName) ($([math]::Round($setupExe.Length / 1MB, 1)) MB)"
            }
        } else {
            Write-Err "Setup compiler failed with exit code $LASTEXITCODE"
        }
    }
}

# ---------------------------------------------------------------------------
# Windows Installer (.msi via WiX Toolset)
# ---------------------------------------------------------------------------

if ($Msi) {
    Write-Step "Building Windows Installer Package (.msi via WiX Toolset)..."
    $wix = Find-WiX
    if (-not $wix) {
        Write-Err "WiX Toolset (wix.exe) not found."
        Write-Host "  Install WiX with: dotnet tool install --global wix --version 5.0.2" -ForegroundColor Yellow
        Write-Host "  And install UI extension: wix extension add -g WixToolset.UI.wixext/5.0.2" -ForegroundColor Yellow
    } else {
        $wxsFile = Join-Path $root 'installer\setup.wxs'
        $distDir = Join-Path $root 'dist'
        if (-not (Test-Path $distDir)) { New-Item -ItemType Directory -Path $distDir | Out-Null }

        $version = "3.0.1"
        if (Test-Path $project) {
            $csprojXml = [xml](Get-Content $project)
            $verNode = $csprojXml.SelectSingleNode("//Version")
            if ($verNode -and $verNode.InnerText) { $version = $verNode.InnerText.Trim() }
        }

        $assetsDir = Join-Path $root 'src\DevOpsToolsInstaller\Assets'
        $outputMsi = Join-Path $distDir "DevOpsToolsInstaller_v${version}_x64.msi"

        Write-Host "  Compiling with WiX Toolset ($outputMsi)..." -ForegroundColor Gray
        & $wix build $wxsFile -ext WixToolset.UI.wixext -arch x64 -d "SourceDir=$pubDir" -d "AssetsDir=$assetsDir" -d "AppVersion=$version" -o $outputMsi
        if ($LASTEXITCODE -eq 0 -and (Test-Path $outputMsi)) {
            $msiItem = Get-Item $outputMsi
            $sizeMB = [math]::Round($msiItem.Length / 1MB, 1)
            Write-Ok "Windows Installer (.msi) generated: $($msiItem.FullName) ($sizeMB MB)"
        } else {
            Write-Err "WiX compiler failed with exit code $LASTEXITCODE"
        }
    }
}

# ---------------------------------------------------------------------------
# Auto-launch
# ---------------------------------------------------------------------------

if ($Run) {
    Write-Step "Launching..."
    try {
        Start-Process -FilePath $exe
        Write-Ok "Launched - check your taskbar"
    } catch {
        Write-Err "Failed to launch: $_"
    }
}