#Requires -RunAsAdministrator
<#
Hämtar språk- och regioninställningar i Windows 10/11.

Det som kontrolleras:
- Aktuell användares Windows-språklista
- Aktuell användares åsidosättning av visningsspråk
- Aktuell användares kultur/format
- Aktuell användares UI-kultur
- Systemets lokala språk/regioninställning
- Hemplats
- Åsidosättning av standardinmatningsmetod
- Alternativ för språkfältet
- Inställningar för att välja bort språklistan
- Installerade/tillgängliga språkfunktioner för valda språk
- Registersnapshot för aktuell användare och välkomst-/systemkontots internationella inställningar

Skrivskyddat:
- Installerar ingenting
- Ändrar inget språk
- Kopierar inga inställningar
- Ändrar inte registret

Språk som kontrolleras som standard:
- Engelska (en-US)
- Svenska (sv-SE)
- Norska Bokmål (nb-NO)
#>

param(
    # Språktaggar som ska kontrolleras mot installerade/tillgängliga språkfunktioner.
    [string[]]$LanguageTags = @(
        "en-US",
        "sv-SE",
        "nb-NO"
    ),

    # Visar alla språkrelaterade Windows-funktioner, inte bara de valda språken.
    [switch]$ShowAllLanguageCapabilities,

    # Exporterar hela rapporten som JSON om växeln anges.
    [switch]$ExportJson,

    # Sökväg för JSON-exporten.
    [string]$JsonPath = "$env:USERPROFILE\Desktop\WindowsLanguageSettings.json"
)

# Stoppa scriptet vid fel som annars kan passera tyst.
$ErrorActionPreference = "Stop"

function Write-Section {
    param(
        [string]$Title
    )

    # Skriver en tom rad och en tydlig rubrik för nästa rapportdel.
    Write-Host ""
    Write-Host "== $Title =="
}

function Get-SafeValue {
    param(
        [scriptblock]$ScriptBlock,
        [string]$Fallback = "Unavailable"
    )

    # Kör ett kommando säkert och returnerar ett tydligt fallback-värde vid fel eller tomt resultat.
    try {
        $result = & $ScriptBlock

        if ($null -eq $result) {
            return $Fallback
        }

        return $result
    }
    catch {
        return "$Fallback - $($_.Exception.Message)"
    }
}

function Get-RegistryInternationalSnapshot {
    param(
        [string]$Scope,
        [string]$Path
    )

    # Läser internationella registervärden för angiven nyckel och paketerar dem som ett objekt.
    try {
        $item = Get-ItemProperty -Path $Path -ErrorAction Stop

        [PSCustomObject]@{
            Scope       = $Scope
            RegistryKey = $Path
            LocaleName  = $item.LocaleName
            Locale      = $item.Locale
            Language    = $item.sLanguage
            Country     = $item.sCountry
            ShortDate   = $item.sShortDate
            LongDate    = $item.sLongDate
            TimeFormat  = $item.sTimeFormat
            ShortTime   = $item.sShortTime
            Decimal     = $item.sDecimal
            Thousand    = $item.sThousand
            Currency    = $item.sCurrency
        }
    }
    catch {
        # Om registernyckeln inte kan läsas tas felet med i rapporten i stället för att avbryta scriptet.
        [PSCustomObject]@{
            Scope       = $Scope
            RegistryKey = $Path
            Error       = $_.Exception.Message
        }
    }
}

Write-Host ""
Write-Host "Windows language/settings audit"
Write-Host "This script only reads settings. It does not change anything."

# Samlar alla resultat i en ordnad tabell som senare kan exporteras till JSON.
$report = [ordered]@{}

Write-Section "Computer info"

# Hämtar grundläggande information om Windows-installationen och datorn.
$computerInfo = Get-SafeValue {
    Get-ComputerInfo | Select-Object `
        WindowsProductName,
        WindowsVersion,
        OsHardwareAbstractionLayer,
        OsArchitecture,
        CsName
}

$report.ComputerInfo = $computerInfo
$computerInfo | Format-List

Write-Section "Current user language list"

# Hämtar språklistan för den inloggade användaren och gör den lättare att läsa.
$userLanguageList = Get-SafeValue {
    Get-WinUserLanguageList | ForEach-Object {
        [PSCustomObject]@{
            LanguageTag              = $_.LanguageTag
            Autonym                  = $_.Autonym
            EnglishName              = $_.EnglishName
            LocalizedName            = $_.LocalizedName
            InputMethodTips          = ($_.InputMethodTips -join ", ")
            Spellchecking            = $_.Spellchecking
            Handwriting              = $_.Handwriting
        }
    }
}

$report.UserLanguageList = $userLanguageList
$userLanguageList | Format-Table -AutoSize

Write-Section "Current user UI language override"

# Kontrollerar om användaren har satt ett separat visningsspråk som åsidosätter språklistan.
$uiLanguageOverride = Get-SafeValue {
    $value = Get-WinUILanguageOverride

    if ($null -eq $value) {
        [PSCustomObject]@{
            UIOverride = "No explicit override set"
        }
    }
    else {
        [PSCustomObject]@{
            Name        = $value.Name
            DisplayName = $value.DisplayName
        }
    }
}

$report.UILanguageOverride = $uiLanguageOverride
$uiLanguageOverride | Format-List

Write-Section "Current user culture and UI culture"

# Hämtar användarens format/kultur samt UI-kultur från PowerShell/.NET.
$cultureInfo = [PSCustomObject]@{
    CultureName        = (Get-Culture).Name
    CultureDisplayName = (Get-Culture).DisplayName
    UICultureName      = (Get-UICulture).Name
    UICultureDisplay   = (Get-UICulture).DisplayName
}

$report.CultureInfo = $cultureInfo
$cultureInfo | Format-List

Write-Section "Computer-wide system locale"

# Hämtar systemets lokala inställning, vilket bland annat påverkar äldre icke-Unicode-program.
$systemLocale = Get-SafeValue {
    $value = Get-WinSystemLocale

    [PSCustomObject]@{
        Name        = $value.Name
        DisplayName = $value.DisplayName
    }
}

$report.SystemLocale = $systemLocale
$systemLocale | Format-List

Write-Section "Home location"

# Hämtar Windows-inställningen för hemplats/region.
$homeLocation = Get-SafeValue {
    Get-WinHomeLocation
}

$report.HomeLocation = $homeLocation
$homeLocation | Format-List

Write-Section "Default input method override"

# Kontrollerar om en specifik standardinmatningsmetod har valts.
$defaultInputMethodOverride = Get-SafeValue {
    $value = Get-WinDefaultInputMethodOverride

    if ([string]::IsNullOrWhiteSpace($value)) {
        [PSCustomObject]@{
            DefaultInputMethodOverride = "No explicit override set"
        }
    }
    else {
        [PSCustomObject]@{
            DefaultInputMethodOverride = $value
        }
    }
}

$report.DefaultInputMethodOverride = $defaultInputMethodOverride
$defaultInputMethodOverride | Format-List

Write-Section "Language bar options"

# Hämtar inställningar för språkfältet och tangentbords-/inmatningsindikatorn.
$languageBarOptions = Get-SafeValue {
    Get-WinLanguageBarOption
}

$report.LanguageBarOptions = $languageBarOptions
$languageBarOptions | Format-List

Write-Section "Language-list opt-out settings"

# Kontrollerar om kultur och Accept-Language ska hämtas från språklistan eller inte.
$optOutSettings = [PSCustomObject]@{
    CultureFromLanguageListOptOut        = Get-SafeValue { Get-WinCultureFromLanguageListOptOut }
    AcceptLanguageFromLanguageListOptOut = Get-SafeValue { Get-WinAcceptLanguageFromLanguageListOptOut }
}

$report.OptOutSettings = $optOutSettings
$optOutSettings | Format-List

Write-Section "Language capabilities for selected languages"

# Typer av språkfunktioner som Windows kan installera per språk.
$capabilityPrefixes = @(
    "Language.Basic",
    "Language.OCR",
    "Language.Speech",
    "Language.TextToSpeech",
    "Language.Handwriting"
)

# Hämtar alla Windows Capabilities en gång och filtrerar sedan lokalt per språktagg.
$allCapabilities = Get-SafeValue {
    Get-WindowsCapability -Online
}

$selectedLanguageCapabilities = @()

foreach ($languageTag in $LanguageTags) {
    foreach ($prefix in $capabilityPrefixes) {
        # Matcha Windows Capability-namn som hör till aktuell funktionstyp och språktagg.
        $matches = $allCapabilities | Where-Object {
            $_.Name -like "$prefix*~~~$languageTag~*"
        }

        if (-not $matches) {
            # Saknad matchning rapporteras uttryckligen så det syns att kontrollen gjordes.
            $selectedLanguageCapabilities += [PSCustomObject]@{
                LanguageTag    = $languageTag
                CapabilityType = $prefix
                Name           = ""
                State          = "Not available on this system"
            }

            continue
        }

        foreach ($capability in $matches) {
            # Lägg till varje funnen språkfunktion och dess installationsstatus i rapporten.
            $selectedLanguageCapabilities += [PSCustomObject]@{
                LanguageTag    = $languageTag
                CapabilityType = $prefix
                Name           = $capability.Name
                State          = $capability.State
            }
        }
    }
}

$report.SelectedLanguageCapabilities = $selectedLanguageCapabilities
$selectedLanguageCapabilities | Format-Table -AutoSize

if ($ShowAllLanguageCapabilities) {
    Write-Section "All language capabilities"

    # Valfri fullständig lista över alla språkrelaterade Windows Capabilities.
    $allLanguageCapabilities = $allCapabilities | Where-Object {
        $_.Name -like "Language.*"
    } | Select-Object Name, State

    $report.AllLanguageCapabilities = $allLanguageCapabilities
    $allLanguageCapabilities | Format-Table -AutoSize
}

Write-Section "Registry snapshot: international settings"

# Läser samma typ av internationella registervärden för användaren och standard/systemprofilen.
$registrySnapshots = @(
    Get-RegistryInternationalSnapshot `
        -Scope "Current user" `
        -Path "HKCU:\Control Panel\International"

    Get-RegistryInternationalSnapshot `
        -Scope "Welcome screen / system account default hive" `
        -Path "Registry::HKEY_USERS\.DEFAULT\Control Panel\International"
)

$report.RegistrySnapshots = $registrySnapshots
$registrySnapshots | Format-Table -AutoSize

Write-Section "Summary"

# Kort sammanfattning av de viktigaste värdena för snabb kontroll.
$summary = [PSCustomObject]@{
    CurrentUserPrimaryLanguage = if ($userLanguageList -and $userLanguageList[0]) { $userLanguageList[0].LanguageTag } else { "Unknown" }
    UIOverride                 = if ($uiLanguageOverride.Name) { $uiLanguageOverride.Name } else { "No explicit override set" }
    Culture                    = $cultureInfo.CultureName
    UICulture                  = $cultureInfo.UICultureName
    SystemLocale               = if ($systemLocale.Name) { $systemLocale.Name } else { "Unknown" }
    CheckedLanguageTags        = ($LanguageTags -join ", ")
}

$report.Summary = $summary
$summary | Format-List

if ($ExportJson) {
    Write-Section "Exporting JSON report"

    # Exporterar den ordnade rapporten till JSON med tillräckligt djup för nästlade objekt.
    $report | ConvertTo-Json -Depth 8 | Out-File -FilePath $JsonPath -Encoding UTF8

    Write-Host "Exported to:"
    Write-Host $JsonPath
}

Write-Host ""
Write-Host "Done. No settings were changed."