# SECURITY-METADATA-BEGIN
# Product: Klast
# Purpose: terminal compatibility preview
# Executable download: none
# Filesystem writes: none
# Elevated privileges: none
# Network: optional HTTPS POST diagnostic metadata to /api/installer-event
# Diagnostics default: not sent
# Diagnostics consent: interactive yes or KLAST_SHARE_DIAGNOSTICS=1
# Client telemetry: client, platform, architecture, device model, OS, and timezone
# Server-derived: request IP, country, network timezone, provider, and organization
# Verification: https://klast.club/security
# Manifest: https://klast.club/.well-known/installer-security.json
# SECURITY-METADATA-END

# Klast compatibility preview. This script intentionally downloads and installs no package.
$ErrorActionPreference = "Stop"

$version = "0.1.1"
$packageSize = "19.4"
$telemetryUrl = "https://klast.club/api/installer-event"
$checkMark = [char]0x2713
$crossMark = [char]0x2715
$block = [char]0x2588
$chevron = [char]0x203A

$architecture = try {
    [System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture.ToString().ToLowerInvariant()
} catch {
    [string]$env:PROCESSOR_ARCHITECTURE
}

$arch = switch -Regex ($architecture) {
    "arm64|aarch64" { "arm64"; break }
    "x64|amd64" { "x64"; break }
    default { "unknown" }
}

$platform = "windows-$arch"
$package = "klast-$platform.zip"
$fast = $env:KLAST_INSTALLER_TEST -eq "1"

function Get-WindowsName([string]$Caption, [string]$BuildNumber) {
    $captionText = $Caption.Trim()
    $serverMatch = [regex]::Match($captionText, "Windows Server\s+\d{4}", "IgnoreCase")
    if ($serverMatch.Success) { return $serverMatch.Value }

    $build = 0
    [void][int]::TryParse($BuildNumber.Trim(), [ref]$build)
    if ($build -ge 22000) { return "Windows 11" }
    if ($build -ge 10240) { return "Windows 10" }

    $nameMatch = [regex]::Match(
        $captionText,
        "Windows\s+(?:8\.1|8|7|Vista|XP)",
        "IgnoreCase"
    )
    if ($nameMatch.Success) { return $nameMatch.Value }
    return "Windows"
}

function Get-DeviceBrand([string]$Manufacturer) {
    $value = $Manufacturer.Trim()
    switch -Regex ($value) {
        "ASUSTeK|ASUS" { return "ASUS" }
        "Micro-Star|(?:^|\s)MSI(?:$|\s)" { return "MSI" }
        "Lenovo" { return "Lenovo" }
        "Dell" { return "Dell" }
        "Hewlett-Packard|(?:^|\s)HP(?:$|\s)" { return "HP" }
        "Acer" { return "Acer" }
        "Microsoft" { return "Microsoft" }
        "Samsung" { return "Samsung" }
        "Huawei" { return "Huawei" }
        "HONOR" { return "HONOR" }
        "Xiaomi" { return "Xiaomi" }
        "GIGABYTE" { return "GIGABYTE" }
        "Razer" { return "Razer" }
        "Framework" { return "Framework" }
        "Apple" { return "Apple" }
        default { return "unknown" }
    }
}

function Get-FriendlyDeviceModel(
    [string]$Manufacturer,
    [string]$SystemFamily,
    [string]$Model
) {
    $brand = Get-DeviceBrand $Manufacturer
    $source = "$SystemFamily $Model"
    $families = @(
        @("(?i)VivoBook", "VivoBook"),
        @("(?i)ZenBook", "ZenBook"),
        @("(?i)ExpertBook", "ExpertBook"),
        @("(?i)ProArt", "ProArt"),
        @("(?i)(?:^|[^a-z0-9])ROG(?:[^a-z0-9]|$)", "ROG"),
        @("(?i)(?:^|[^a-z0-9])TUF(?:[^a-z0-9]|$)", "TUF"),
        @("(?i)ThinkPad", "ThinkPad"),
        @("(?i)IdeaPad", "IdeaPad"),
        @("(?i)ThinkBook", "ThinkBook"),
        @("(?i)Legion", "Legion"),
        @("(?i)(?:^|[^a-z0-9])Yoga(?:[^a-z0-9]|$)", "Yoga"),
        @("(?i)Inspiron", "Inspiron"),
        @("(?i)Latitude", "Latitude"),
        @("(?i)Precision", "Precision"),
        @("(?i)(?:^|[^a-z0-9])XPS(?:[^a-z0-9]|$)", "XPS"),
        @("(?i)Alienware", "Alienware"),
        @("(?i)Pavilion", "Pavilion"),
        @("(?i)(?:^|[^a-z0-9])ENVY(?:[^a-z0-9]|$)", "ENVY"),
        @("(?i)Spectre", "Spectre"),
        @("(?i)EliteBook", "EliteBook"),
        @("(?i)ProBook", "ProBook"),
        @("(?i)(?:^|[^a-z0-9])OMEN(?:[^a-z0-9]|$)", "OMEN"),
        @("(?i)Victus", "Victus"),
        @("(?i)Aspire", "Aspire"),
        @("(?i)(?:^|[^a-z0-9])Swift(?:[^a-z0-9]|$)", "Swift"),
        @("(?i)Predator", "Predator"),
        @("(?i)(?:^|[^a-z0-9])Nitro(?:[^a-z0-9]|$)", "Nitro"),
        @("(?i)TravelMate", "TravelMate"),
        @("(?i)Surface", "Surface"),
        @("(?i)Galaxy[ _-]*Book", "Galaxy Book"),
        @("(?i)MateBook", "MateBook"),
        @("(?i)MagicBook", "MagicBook"),
        @("(?i)RedmiBook", "RedmiBook"),
        @("(?i)(?:^|[^a-z0-9])AORUS(?:[^a-z0-9]|$)", "AORUS"),
        @("(?i)(?:^|[^a-z0-9])AERO(?:[^a-z0-9]|$)", "AERO"),
        @("(?i)(?:^|[^a-z0-9])Modern(?:[^a-z0-9]|$)", "Modern"),
        @("(?i)(?:^|[^a-z0-9])Katana(?:[^a-z0-9]|$)", "Katana"),
        @("(?i)(?:^|[^a-z0-9])Blade(?:[^a-z0-9]|$)", "Blade"),
        @("(?i)Framework[ _-]*Laptop", "Framework Laptop"),
        @("(?i)MacBook[ _-]*Pro|MacBookPro", "MacBook Pro"),
        @("(?i)MacBook[ _-]*Air|MacBookAir", "MacBook Air"),
        @("(?i)(?:^|[^a-z0-9])iMac(?:[^a-z0-9]|$)", "iMac")
    )

    foreach ($family in $families) {
        if ($source -match $family[0]) {
            $familyName = $family[1]
            if ($brand -eq "unknown") { return $familyName }
            if ($familyName.StartsWith($brand, [StringComparison]::OrdinalIgnoreCase)) {
                return $familyName
            }
            return "$brand $familyName"
        }
    }

    if ($brand -ne "unknown") { return $brand }
    return "unknown"
}

$deviceModel = "unknown"
$osDescription = "Windows"
$clientTimezone = ""

function Wait-Preview([int]$Milliseconds) {
    if (-not $fast) { Start-Sleep -Milliseconds $Milliseconds }
}

function Write-Check([string]$Label, [string]$Value) {
    Write-Host $checkMark -ForegroundColor Green -NoNewline
    Write-Host (" {0,-20} {1}" -f $Label, $Value)
    Wait-Preview 120
}

function Get-DiagnosticsConsent {
    if ($fast) { return $false }
    if ($env:KLAST_SHARE_DIAGNOSTICS -match "^(?i:1|true|yes)$") { return $true }
    if ($env:KLAST_SHARE_DIAGNOSTICS -match "^(?i:0|false|no)$") { return $false }
    if (-not [Environment]::UserInteractive -or [Console]::IsInputRedirected) { return $false }

    Write-Host ""
    Write-Host "Optional diagnostics: https://klast.club/security#telemetry" -ForegroundColor DarkGray
    Write-Host "Includes OS, architecture, model, timezone, and request IP." -ForegroundColor DarkGray
    try {
        $answer = Read-Host "Share one diagnostic event? [y/N]"
        return $answer -match "^(?i:y|yes)$"
    } catch {
        return $false
    }
}

Write-Host "Klast Installer"
Write-Host ""
Write-Host "Checking Klast compatibility"
Write-Host ""
Write-Check "Detected platform" $platform
Write-Check "Resolved release" "v$version"
Write-Check "Expected package" $package
Write-Check "Expected size" "$packageSize MB"
Write-Host ""
Write-Host ("{0} Running compatibility preview" -f $chevron)

$barWidth = 32
foreach ($percent in @(4, 12, 23, 36, 51, 67, 82, 94, 100)) {
    $filled = [Math]::Floor($percent * $barWidth / 100)
    $empty = $barWidth - $filled
    Write-Host "`r" -NoNewline
    Write-Host ([string]$block * $filled) -ForegroundColor Magenta -NoNewline
    Write-Host ((" " * $empty) + (" {0,3}%" -f $percent)) -NoNewline
    Wait-Preview 70
}
Write-Host ""
Write-Host ""

Write-Check "Preview completed" "no package downloaded"
Wait-Preview 180
Write-Host ""
Write-Host ("{0} Installation failed" -f $crossMark) -ForegroundColor Red
Write-Host "  Error: Native binary unavailable for validation" -ForegroundColor Red
Write-Host "  No package was downloaded or installed by this compatibility preview." -ForegroundColor DarkGray
Write-Host ""

# Diagnostics remain available, but are sent only after explicit consent. The
# server derives location, provider, and organization from the request IP.
if (Get-DiagnosticsConsent) {
    try {
        try {
            $computerSystem = Get-CimInstance -ClassName Win32_ComputerSystem -ErrorAction Stop
            $deviceModel = Get-FriendlyDeviceModel `
                ([string]$computerSystem.Manufacturer) `
                ([string]$computerSystem.SystemFamily) `
                ([string]$computerSystem.Model)
        } catch {}
        try {
            $operatingSystem = Get-CimInstance -ClassName Win32_OperatingSystem -ErrorAction Stop
            $osDescription = Get-WindowsName `
                ([string]$operatingSystem.Caption) `
                ([string]$operatingSystem.BuildNumber)
        } catch {}
        try { $clientTimezone = [TimeZoneInfo]::Local.Id } catch {}

        $client = "PowerShell $($PSVersionTable.PSVersion.ToString())"
        $headers = @{
            "X-Klast-Installer-Client" = $client
            "X-Klast-Installer-Platform" = "windows"
            "X-Klast-Installer-Arch" = $arch
            "X-Klast-Client-Timezone" = $clientTimezone
        }
        $telemetryBody = @{
            client = $client
            platform = "windows"
            architecture = $arch
            model = $deviceModel
            os = $osDescription
        }
        Invoke-WebRequest -UseBasicParsing -Method Post -Uri $telemetryUrl -Headers $headers -Body $telemetryBody -ContentType "application/x-www-form-urlencoded" -TimeoutSec 4 | Out-Null
        Write-Host "$checkMark Diagnostics sent with consent." -ForegroundColor Green
    } catch {
        Write-Host "Diagnostics could not be sent." -ForegroundColor DarkGray
    }
} else {
    Write-Host "Diagnostics not sent." -ForegroundColor DarkGray
}

exit 0