setup-profile.ps1

[CmdletBinding(SupportsShouldProcess)]
param()

$ErrorActionPreference = 'Stop'
Set-StrictMode -Version Latest

$fontDownloadUrl = 'https://github.com/ryanoasis/nerd-fonts/releases/download/v3.4.0/CascadiaCode.zip'
$fontExpectedSha256 = '8d80993351a0a6b69a998e5c72060b7200c4f1af1f32b3ad4d8cad27c245940e'
$terminalFontFace = 'CaskaydiaCove NF'

$profileContent = @'
Import-Module posh-git
Import-Module Terminal-Icons

if ($PSVersionTable.PSVersion -ge [version]'7.4') {
    Import-Module -Name Microsoft.WinGet.CommandNotFound
}

$GitPromptSettings.DefaultPromptPrefix.Text = '$(Get-Date -f "MM-dd HH:mm:ss") '
$GitPromptSettings.DefaultPromptPrefix.ForegroundColor = [ConsoleColor]::Magenta
$GitPromptSettings.DefaultPromptAbbreviateHomeDirectory = $true
$GitPromptSettings.DefaultPromptPath.ForegroundColor = 'Orange'
$GitPromptSettings.DefaultPromptBeforeSuffix.Text = '`n'

Set-PSReadLineKeyHandler -Key Ctrl+d -Function DeleteCharOrExit

function code {
    & code-insiders @args
}

Set-Alias -Name c -Value code
Set-Alias -Name codei -Value code-insiders

function reload-profile {
    . $PROFILE.CurrentUserAllHosts
}

function which {
    Get-Command @args
}

function touch {
    param(
        [Parameter(Mandatory, ValueFromRemainingArguments)]
        [string[]]$Path
    )

    foreach ($item in $Path) {
        if (Test-Path $item) {
            (Get-Item $item).LastWriteTime = Get-Date
            continue
        }

        New-Item -ItemType File -Path $item -Force | Out-Null
    }
}

function git-status {
    git status @args
}

function git-graph {
    git log --oneline --graph --decorate @args
}

function git-root {
    $root = git rev-parse --show-toplevel 2>$null
    if ($LASTEXITCODE -ne 0 -or [string]::IsNullOrWhiteSpace($root)) {
        Write-Error 'Not currently inside a Git repository.'
        return
    }

    Set-Location $root.Trim()
}
'@

$targetProfile = $PROFILE.CurrentUserAllHosts

function New-DirectoryIfMissing {
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter(Mandatory)]
        [string]$Path
    )

    if (Test-Path -Path $Path) {
        if (-not (Test-Path -Path $Path -PathType Container)) {
            throw "Path exists but is not a directory: $Path"
        }

        return
    }

    if ($PSCmdlet.ShouldProcess($Path, 'Create directory')) {
        New-Item -ItemType Directory -Path $Path -Force | Out-Null
    }
}

function Remove-JsonComments {
    param(
        [Parameter(Mandatory)]
        [string]$Content
    )

    $builder = New-Object System.Text.StringBuilder
    $inString = $false
    $inLineComment = $false
    $inBlockComment = $false
    $isEscaped = $false

    for ($index = 0; $index -lt $Content.Length; $index++) {
        $currentChar = $Content[$index]
        $nextChar = if ($index + 1 -lt $Content.Length) { $Content[$index + 1] } else { [char]0 }

        if ($inLineComment) {
            if ($currentChar -eq "`n") {
                $inLineComment = $false
                [void]$builder.Append($currentChar)
            }

            continue
        }

        if ($inBlockComment) {
            if ($currentChar -eq '*' -and $nextChar -eq '/') {
                $inBlockComment = $false
                $index++
            }

            continue
        }

        if (-not $inString -and $currentChar -eq '/' -and $nextChar -eq '/') {
            $inLineComment = $true
            $index++
            continue
        }

        if (-not $inString -and $currentChar -eq '/' -and $nextChar -eq '*') {
            $inBlockComment = $true
            $index++
            continue
        }

        [void]$builder.Append($currentChar)

        if ($currentChar -eq '"' -and -not $isEscaped) {
            $inString = -not $inString
        }

        if ($inString -and $currentChar -eq '\\' -and -not $isEscaped) {
            $isEscaped = $true
        } else {
            $isEscaped = $false
        }
    }

    return [regex]::Replace($builder.ToString(), ',\s*(?=[}\]])', '')
}

function Read-JsonFile {
    param(
        [Parameter(Mandatory)]
        [string]$Path
    )

    if (-not (Test-Path -Path $Path)) {
        return [ordered]@{}
    }

    $content = Get-Content -Path $Path -Raw
    if ([string]::IsNullOrWhiteSpace($content)) {
        return [ordered]@{}
    }

    try {
        return $content | ConvertFrom-Json -AsHashtable -Depth 100
    } catch {
        $sanitizedContent = Remove-JsonComments -Content $content
        return $sanitizedContent | ConvertFrom-Json -AsHashtable -Depth 100
    }
}

function Get-PropertyValue {
    param(
        [Parameter(Mandatory)]
        [object]$InputObject,

        [Parameter(Mandatory)]
        [string]$Name
    )

    if ($InputObject -is [System.Collections.IDictionary]) {
        return $InputObject[$Name]
    }

    $property = $InputObject.PSObject.Properties[$Name]
    if ($null -ne $property) {
        return $property.Value
    }

    return $null
}

function Write-JsonFile {
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter(Mandatory)]
        [string]$Path,

        [Parameter(Mandatory)]
        [object]$Data
    )

    New-DirectoryIfMissing -Path (Split-Path -Parent $Path)

    if ($PSCmdlet.ShouldProcess($Path, 'Write JSON settings file')) {
        $Data | ConvertTo-Json -Depth 100 | Set-Content -Path $Path -Encoding UTF8
        return $true
    }

    return $false
}

function Install-NerdFont {
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter(Mandatory)]
        [string]$DownloadUrl,

        [Parameter(Mandatory)]
        [string]$ExpectedSha256
    )

    $fontInstallDir = Join-Path -Path $env:LOCALAPPDATA -ChildPath 'Microsoft\Windows\Fonts'
    $fontRegistryPath = 'HKCU:\Software\Microsoft\Windows NT\CurrentVersion\Fonts'

    # Skip installation if the font files and registry entries already exist.
    $existingFontFiles = @(Get-ChildItem -Path $fontInstallDir -Filter 'CaskaydiaCoveNerdFont*' -File -ErrorAction SilentlyContinue)
    $registryKey = Get-Item -Path $fontRegistryPath -ErrorAction SilentlyContinue
    $existingRegistryEntries = @(if ($null -ne $registryKey) {
        $registryKey.Property | Where-Object { $_ -like 'CaskaydiaCoveNerdFont*' }
    })

    $alreadyInstalled = ($existingFontFiles.Count -gt 0) -and ($existingRegistryEntries.Count -gt 0)

    if ($alreadyInstalled) {
        Write-Host 'CaskaydiaCove Nerd Font is already installed. Skipping.' -ForegroundColor Cyan
        return $true
    }

    $tempRoot = Join-Path -Path $env:TEMP -ChildPath 'setup-profile-fonts'
    $zipPath = Join-Path -Path $tempRoot -ChildPath 'CascadiaCode.zip'
    $extractPath = Join-Path -Path $tempRoot -ChildPath 'CascadiaCode'

    New-DirectoryIfMissing -Path $tempRoot
    if (Test-Path -Path $extractPath) {
        if ($PSCmdlet.ShouldProcess($extractPath, 'Reset font extraction directory')) {
            Remove-Item -Path $extractPath -Recurse -Force
        }
    }

    New-DirectoryIfMissing -Path $extractPath
    New-DirectoryIfMissing -Path $fontInstallDir

    if (-not $PSCmdlet.ShouldProcess($fontInstallDir, 'Install CascadiaCode Nerd Font for current user')) {
        return $false
    }

    Write-Host 'Downloading CascadiaCode Nerd Font...' -ForegroundColor Yellow
    Invoke-WebRequest -Uri $DownloadUrl -OutFile $zipPath

    $actualHash = (Get-FileHash -Path $zipPath -Algorithm SHA256).Hash
    if ($actualHash -ine $ExpectedSha256) {
        Remove-Item -Path $zipPath -Force
        throw "SHA256 checksum mismatch for downloaded font archive. Expected '$ExpectedSha256', got '$actualHash'."
    }

    Expand-Archive -Path $zipPath -DestinationPath $extractPath -Force

    $fontFiles = Get-ChildItem -Path $extractPath -Recurse -File |
        Where-Object {
            $_.Extension -in '.ttf', '.otf' -and
            $_.BaseName -like 'CaskaydiaCoveNerdFont*'
        }

    if (-not $fontFiles) {
        throw 'No CaskaydiaCove Nerd Font files were found in the downloaded archive.'
    }

    foreach ($fontFile in $fontFiles) {
        $destinationPath = Join-Path -Path $fontInstallDir -ChildPath $fontFile.Name
        Copy-Item -Path $fontFile.FullName -Destination $destinationPath -Force

        $registryValueName = '{0} (TrueType)' -f $fontFile.BaseName
        New-ItemProperty -Path $fontRegistryPath -Name $registryValueName -Value $fontFile.Name -PropertyType String -Force | Out-Null
    }

    if (-not ('FontChangeBroadcast' -as [type])) {
        Add-Type @"
using System;
using System.Runtime.InteropServices;

public static class FontChangeBroadcast {
    [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
    public static extern IntPtr SendMessageTimeout(
        IntPtr hWnd,
        uint Msg,
        UIntPtr wParam,
        string lParam,
        uint fuFlags,
        uint uTimeout,
        out UIntPtr lpdwResult);
}
"@
    }

    $result = [UIntPtr]::Zero
    [void][FontChangeBroadcast]::SendMessageTimeout(
        [IntPtr]0xffff,
        0x001D,
        [UIntPtr]::Zero,
        $null,
        0x0002,
        1000,
        [ref]$result)

    Write-Host 'Installed CascadiaCode Nerd Font files for the current user.' -ForegroundColor Green
    return $true
}

function Set-WindowsTerminalPowerShellFont {
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter(Mandatory)]
        [string]$FontFace
    )

    $candidatePaths = @(
        (Join-Path -Path $env:LOCALAPPDATA -ChildPath 'Packages\Microsoft.WindowsTerminal_8wekyb3d8bbwe\LocalState\settings.json')
        (Join-Path -Path $env:LOCALAPPDATA -ChildPath 'Packages\Microsoft.WindowsTerminalPreview_8wekyb3d8bbwe\LocalState\settings.json')
        (Join-Path -Path $env:LOCALAPPDATA -ChildPath 'Microsoft\Windows Terminal\settings.json')
    ) | Select-Object -Unique

    $updatedPaths = @()
    $matchedPaths = @()

    foreach ($settingsPath in $candidatePaths) {
        if (-not (Test-Path -Path $settingsPath)) {
            continue
        }

        try {
            $settings = Read-JsonFile -Path $settingsPath
        } catch {
            Write-Warning "Skipping Windows Terminal settings at $settingsPath because the file could not be parsed."
            continue
        }

        if (-not $settings.ContainsKey('profiles') -or $null -eq $settings.profiles) {
            $settings.profiles = [ordered]@{}
        }

        if (-not $settings.profiles.ContainsKey('list') -or $null -eq $settings.profiles.list) {
            Write-Warning "Skipping Windows Terminal settings at $settingsPath because no profiles.list section was found."
            continue
        }

        $profiles = @($settings.profiles.list)
        $powerShellProfile = $profiles |
            Where-Object {
                $profileName = Get-PropertyValue -InputObject $_ -Name 'name'
                $profileSource = Get-PropertyValue -InputObject $_ -Name 'source'
                $profileCommandLine = Get-PropertyValue -InputObject $_ -Name 'commandline'

                $profileName -eq 'PowerShell' -or
                $profileSource -eq 'Windows.Terminal.PowershellCore' -or
                $profileCommandLine -match 'pwsh|powershell'
            } |
            Select-Object -First 1

        if (-not $powerShellProfile) {
            Write-Warning "Skipping Windows Terminal settings at $settingsPath because no PowerShell profile was found."
            continue
        }

        $matchedPaths += $settingsPath

        if (-not $powerShellProfile.ContainsKey('font') -or $null -eq $powerShellProfile.font) {
            $powerShellProfile.font = [ordered]@{}
        }

        $powerShellProfile.font.face = $FontFace
        if (Write-JsonFile -Path $settingsPath -Data $settings) {
            $updatedPaths += $settingsPath
        }
    }

    if ($matchedPaths.Count -eq 0) {
        Write-Warning 'Windows Terminal settings were not updated because no supported settings file was found.'
        return
    }

    foreach ($updatedPath in $updatedPaths) {
        Write-Host "Updated Windows Terminal font in $updatedPath" -ForegroundColor Green
    }
}

function Set-VSCodeTerminalFont {
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter(Mandatory)]
        [string]$FontFace
    )

    $candidatePaths = @(
        (Join-Path -Path $env:APPDATA -ChildPath 'Code\User\settings.json')
        (Join-Path -Path $env:APPDATA -ChildPath 'Code - Insiders\User\settings.json')
    ) | Select-Object -Unique

    $existingPaths = @($candidatePaths | Where-Object { Test-Path -Path $_ })
    if ($existingPaths.Count -eq 0) {
        $existingPaths = @($candidatePaths[0])
    }

    $updatedPaths = @()

    foreach ($settingsPath in $existingPaths) {
        try {
            $settings = Read-JsonFile -Path $settingsPath
        } catch {
            Write-Warning "Skipping VS Code settings at $settingsPath because the file could not be parsed."
            continue
        }

        $settings['terminal.integrated.fontFamily'] = $FontFace
        if (Write-JsonFile -Path $settingsPath -Data $settings) {
            $updatedPaths += $settingsPath
            Write-Host "Updated VS Code terminal font in $settingsPath" -ForegroundColor Green
        }
    }

    return $updatedPaths.Count -gt 0
}

Write-Host "Bootstrapping PowerShell all-hosts profile..." -ForegroundColor Cyan
Write-Host "Target profile: $targetProfile" -ForegroundColor DarkGray

if (-not (Get-PackageProvider -Name NuGet -ErrorAction SilentlyContinue)) {
    if ($PSCmdlet.ShouldProcess('NuGet package provider', 'Install package provider for current user')) {
        Install-PackageProvider -Name NuGet -Force -Scope CurrentUser
    }
}

if (-not (Get-Module -ListAvailable -Name PowerShellGet)) {
    if ($PSCmdlet.ShouldProcess('PowerShellGet', 'Install PowerShell module for current user')) {
        Install-Module -Name PowerShellGet -Force -Scope CurrentUser
    }
}

try {
    if ($PSCmdlet.ShouldProcess('PSGallery', 'Set installation policy to Trusted')) {
        Set-PSRepository -Name PSGallery -InstallationPolicy Trusted
    }
} catch {
    Write-Warning "Could not mark PSGallery as trusted. Continuing."
}

$modules = @(
    'posh-git'
    'Terminal-Icons'
)

if ($PSVersionTable.PSVersion -ge [version]'7.4') {
    $modules += 'Microsoft.WinGet.CommandNotFound'
} else {
    Write-Warning "Skipping Microsoft.WinGet.CommandNotFound because it requires PowerShell 7.4+."
}

foreach ($module in $modules) {
    if (-not (Get-Module -ListAvailable -Name $module)) {
        if ($PSCmdlet.ShouldProcess($module, 'Install PowerShell module')) {
            Write-Host "Installing $module..." -ForegroundColor Yellow
            Install-Module -Name $module -Scope CurrentUser -Force -AllowClobber
        }
    } else {
        Write-Host "$module is already installed." -ForegroundColor DarkGray
    }
}

$profileDir = Split-Path -Parent $targetProfile
New-DirectoryIfMissing -Path $profileDir

$profileWritten = $false
if ($PSCmdlet.ShouldProcess($targetProfile, 'Write PowerShell profile')) {
    Set-Content -Path $targetProfile -Value $profileContent -Encoding UTF8
    $profileWritten = $true
}

Install-NerdFont -DownloadUrl $fontDownloadUrl -ExpectedSha256 $fontExpectedSha256 | Out-Null
Set-WindowsTerminalPowerShellFont -FontFace $terminalFontFace | Out-Null
Set-VSCodeTerminalFont -FontFace $terminalFontFace | Out-Null

if ($profileWritten) {
    Write-Host "Profile written to $targetProfile" -ForegroundColor Green
}

if ($profileWritten -and (Test-Path $targetProfile) -and $PSCmdlet.ShouldProcess('current session', 'Load updated profile')) {
    . $targetProfile
    Write-Host 'Profile loaded into the current session.' -ForegroundColor Green
} else {
    Write-Host 'Restart PowerShell to load the new profile.' -ForegroundColor Green
}