Harry Caskey

<#
.SYNOPSIS
    Captures or restores the active Windows power configuration.

.DESCRIPTION
    Designed for use in Configuration Manager OS upgrade task sequences where custom
    power plans need to survive the upgrade process:

    -Capture mode: Reads the active power scheme GUID using powercfg, saves the GUID
     to a text file, and exports the full scheme to a .pow file on the system drive.

    -Restore mode: Imports the saved .pow file, sets the captured GUID as the active
     scheme, then cleans up the temporary files.

    Run -Capture in a pre-upgrade step and -Restore in a post-upgrade step.

.PARAMETER Capture
    Export the current active power scheme to the system drive.

.PARAMETER Restore
    Import a previously captured power scheme and set it as active.

.NOTES
    FileName : Save-PowerConfiguration.ps1
    Author   : Harry Caskey
    Created  : 2019-10-29
    Modified : 2026-03-20
    Version  : 2.0
    Platform : Windows (task sequence or standalone)

.EXAMPLE
    .\Save-PowerConfiguration.ps1 -Capture
    Saves the current power scheme to C:\<COMPUTERNAME>.PowerGUID.txt and .pow file.

.EXAMPLE
    .\Save-PowerConfiguration.ps1 -Restore
    Restores the previously captured scheme and cleans up temp files.
#>

[CmdletBinding()]
param(
    [Parameter(ParameterSetName = 'Capture')]
    [switch]$Capture,

    [Parameter(ParameterSetName = 'Restore')]
    [switch]$Restore
)

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

$guidFile = Join-Path $env:SystemDrive "$env:COMPUTERNAME.PowerGUID.txt"
$powFile  = Join-Path $env:SystemDrive "$env:COMPUTERNAME.pow"

if ($Capture) {
    # Get the active power scheme — output looks like:
    # "Power Scheme GUID: 381b4222-f694-41f0-9685-ff5bb260df2e  (Balanced)"
    $schemeOutput = powercfg /getactivescheme
    $guid = ($schemeOutput -replace '.*GUID:\s*' -replace '\s*\(.*').Trim()

    if (-not $guid) {
        Write-Error 'Could not determine the active power scheme GUID.'
        return
    }

    # Save the GUID and export the full scheme
    Set-Content -Path $guidFile -Value $guid
    Start-Process -FilePath 'powercfg' -ArgumentList "/export `"$powFile`" $guid" -Wait -WindowStyle Hidden

    Write-Output "Captured power scheme: $guid"
    Write-Output "  GUID file: $guidFile"
    Write-Output "  Scheme file: $powFile"
}
elseif ($Restore) {
    if (-not (Test-Path $guidFile)) {
        Write-Error "No saved power GUID found at $guidFile. Did you run -Capture first?"
        return
    }

    $guid = (Get-Content -Path $guidFile).Trim()

    # Import the scheme and set it as active
    Start-Process -FilePath 'powercfg' -ArgumentList "/import `"$powFile`"" -Wait -WindowStyle Hidden
    Start-Process -FilePath 'powercfg' -ArgumentList "/setactive $guid" -Wait -WindowStyle Hidden

    # Clean up temp files
    Remove-Item -Path $powFile, $guidFile -Force -ErrorAction SilentlyContinue

    Write-Output "Restored power scheme: $guid"
}
else {
    Write-Warning 'Specify -Capture or -Restore. Run Get-Help .\Save-PowerConfiguration.ps1 for details.'
}

<#
.SYNOPSIS
    Detects the primary disk number and writes it to a task sequence variable.

.DESCRIPTION
    Queries attached disks via Get-Disk and selects the first one by disk number.
    The result is written into a Configuration Manager task-sequence variable
    (default: "diskNumberIs") so that downstream Format/Partition steps can
    reference it with conditions.

    Most hardware defaults to disk 0, but some systems with NVMe controllers,
    SD card readers, or multi-disk arrays can present disks out of order. This
    script handles those edge cases so you don't format the wrong drive.

    If no disk is found, the variable is set to "NULL" and a warning is logged.

.NOTES
    FileName : Get-TaskSequenceDiskNumber.ps1
    Author   : Harry Caskey
    Created  : 2019-10-23
    Modified : 2026-03-20
    Version  : 2.0
    Requires : MECM/SCCM task-sequence environment (Microsoft.SMS.TSEnvironment COM object)
    Platform : Windows PE / Task Sequence

.EXAMPLE
    # Run as a step inside a Configuration Manager task sequence
    .\Get-TaskSequenceDiskNumber.ps1
    Sets the "diskNumberIs" variable to the first disk number found.
#>

[CmdletBinding()]
param()

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

# The TSEnvironment COM object is only available inside a running task sequence
try {
    $tsEnv = New-Object -ComObject Microsoft.SMS.TSEnvironment
}
catch {
    Write-Error 'This script must run inside a Configuration Manager task sequence. The TSEnvironment COM object is not available.'
    return
}

# Get the first disk by number — Sort-Object ensures consistent ordering
$disk = Get-Disk | Sort-Object Number | Select-Object -First 1

if ($null -ne $disk) {
    $tsEnv.Value('diskNumberIs') = $disk.Number.ToString()
    Write-Output "Task sequence variable 'diskNumberIs' set to $($disk.Number)"
}
else {
    $tsEnv.Value('diskNumberIs') = 'NULL'
    Write-Warning 'No disk detected — variable set to NULL'
}

<#
.SYNOPSIS
    Temporarily suspends BitLocker protection for a specified number of reboots.

.DESCRIPTION
    Checks whether BitLocker is active on the C: drive and, if so, suspends
    protection for the specified reboot count. Protection resumes automatically
    after the designated number of reboots — no manual re-enable required.

    Use this before:
    - BIOS/UEFI firmware updates
    - OS feature upgrades
    - Hardware changes that alter the TPM seal
    - Boot configuration changes

    Without suspending first, these operations would trigger the BitLocker
    recovery screen on next boot.

.PARAMETER RebootCount
    Number of reboots to suspend BitLocker for. Defaults to 2. After this many
    reboots, protection automatically re-engages.

.NOTES
    FileName : Suspend-BitLockerTemporarily.ps1
    Author   : Harry Caskey
    Created  : 2019-10-23
    Modified : 2026-03-20
    Version  : 2.0
    Requires : Administrator privileges, BitLocker module
    Platform : Windows 10/11

.EXAMPLE
    .\Suspend-BitLockerTemporarily.ps1
    Suspends BitLocker for 2 reboots (default).

.EXAMPLE
    .\Suspend-BitLockerTemporarily.ps1 -RebootCount 3
    Suspends BitLocker for 3 reboots.
#>

#Requires -RunAsAdministrator

[CmdletBinding()]
param(
    [ValidateRange(1, 15)]
    [int]$RebootCount = 2
)

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

# Query BitLocker status on the system drive
$volume = Get-BitLockerVolume -MountPoint 'C:' -ErrorAction SilentlyContinue

if (-not $volume) {
    Write-Output 'BitLocker volume information not available for C: drive.'
    return
}

if ($volume.ProtectionStatus -eq 'On') {
    Suspend-BitLocker -MountPoint 'C:' -RebootCount $RebootCount
    Write-Output "BitLocker suspended for $RebootCount reboot(s). Protection will resume automatically."
}
else {
    Write-Output 'BitLocker is not active on C: — no action needed.'
}

<#
.SYNOPSIS
    Detects whether a VPN tunnel is currently active.

.DESCRIPTION
    Queries CIM for network adapters whose names contain common VPN client keywords
    and checks whether any of them are currently enabled (NetEnabled = True).
    Returns $true if a VPN is active, $false otherwise.

    This approach works in environments where the Get-VpnConnection cmdlet isn't
    available (e.g., third-party VPN clients that don't integrate with Windows
    VPN). It queries the Win32_NetworkAdapter CIM class directly.

    Default keywords cover: Cisco AnyConnect, Palo Alto GlobalProtect, Juniper,
    Pulse Secure, generic "VPN", and WireGuard. You can pass custom keywords.

.PARAMETER Keywords
    Array of adapter-name keywords to match. Defaults to common VPN clients.

.NOTES
    FileName : Test-VpnConnection.ps1
    Author   : Harry Caskey
    Created  : 2018-11-20
    Modified : 2026-03-20
    Version  : 2.0
    Platform : Windows (PowerShell 5.1+)

.EXAMPLE
    if (Test-VpnConnection) { Write-Output 'VPN is active' }

.EXAMPLE
    Test-VpnConnection -Keywords 'AnyConnect', 'Zscaler'
    Checks for specific VPN clients only.
#>

[CmdletBinding()]
param(
    [ValidateNotNullOrEmpty()]
    [string[]]$Keywords = @('AnyConnect', 'GlobalProtect', 'Juniper', 'Pulse', 'VPN', 'WireGuard', 'Zscaler')
)

Set-StrictMode -Version Latest

# Build a WQL filter string: Name LIKE '%AnyConnect%' OR Name LIKE '%GlobalProtect%' OR ...
$filterClauses = $Keywords | ForEach-Object { "Name LIKE '%$_%'" }
$filter = "($($filterClauses -join ' OR ')) AND NetEnabled='True'"

$adapter = Get-CimInstance -ClassName Win32_NetworkAdapter -Filter $filter -ErrorAction SilentlyContinue

return [bool]$adapter

<#
.SYNOPSIS
    Adds systems from a text file to a Microsoft Configuration Manager device collection.

.DESCRIPTION
    Reads computer names from a plain-text file (one name per line), validates that each
    device exists in Configuration Manager, and creates a direct membership rule in the
    specified device collection for each found device.

    Designed for bulk onboarding of machines into deployment, patching, or compliance
    collections. Skips blank lines and trims whitespace from each entry.

    Uses -WhatIf support so you can safely preview changes before applying them.

.PARAMETER CollectionName
    The display name of the target Configuration Manager device collection.

.PARAMETER FilePath
    Path to the text file containing one computer name per line.

.NOTES
    FileName : Add-SystemsToCollection.ps1
    Author   : Harry Caskey
    Created  : 2018-11-01
    Modified : 2026-03-20
    Version  : 2.0
    Requires : ConfigurationManager PowerShell module
    Platform : Windows (Configuration Manager console environment)

.EXAMPLE
    .\Add-SystemsToCollection.ps1 -CollectionName "Deployment Ring 1" -FilePath "C:\systems.txt"
    Adds all systems listed in systems.txt to the "Deployment Ring 1" collection.

.EXAMPLE
    .\Add-SystemsToCollection.ps1 -CollectionName "Patching Group A" -FilePath ".\servers.txt" -WhatIf
    Previews what would happen without actually adding any membership rules.
#>

#Requires -Modules ConfigurationManager

[CmdletBinding(SupportsShouldProcess)]
param(
    [Parameter(Mandatory, HelpMessage = 'Name of the target device collection')]
    [ValidateNotNullOrEmpty()]
    [string]$CollectionName,

    [Parameter(Mandatory, HelpMessage = 'Path to text file with computer names')]
    [ValidateScript({ Test-Path -Path $_ -PathType Leaf })]
    [string]$FilePath
)

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

# Read and clean the input file — skip blank lines and trim whitespace
$systems = Get-Content -Path $FilePath |
           ForEach-Object { $_.Trim() } |
           Where-Object { $_ -ne '' }

if (-not $systems) {
    Write-Warning "No system names found in '$FilePath'. File may be empty."
    return
}

Write-Output "Processing $($systems.Count) system(s) for collection '$CollectionName'..."

$added   = 0
$skipped = 0

foreach ($system in $systems) {
    # Look up the device in Configuration Manager
    $device = Get-CMDevice -Name $system -ErrorAction SilentlyContinue

    if (-not $device) {
        Write-Warning "Device not found in CM: $system"
        $skipped++
        continue
    }

    if ($PSCmdlet.ShouldProcess("$system (ResourceID $($device.ResourceID))", "Add to '$CollectionName'")) {
        Add-CMDeviceCollectionDirectMembershipRule `
            -CollectionName $CollectionName `
            -ResourceId $device.ResourceID
        Write-Output "  Added: $system (ResourceID $($device.ResourceID))"
        $added++
    }
}

Write-Output "`nComplete — Added: $added | Skipped: $skipped | Total: $($systems.Count)"

<#
.SYNOPSIS
    Complete Configuration Manager client removal and fresh install with logging.

.DESCRIPTION
    Performs a full lifecycle client repair for Microsoft Configuration Manager
    (formerly SCCM/MECM):

    1. Stops all CM client processes (CcmExec, ccmsetup, msiexec).
    2. Runs ccmsetup /uninstall and waits for completion.
    3. Removes residual files under %WINDIR%\CCM and %WINDIR%\ccmsetup.
    4. Cleans up the CCMSetup registry key.
    5. Performs a fresh install with the specified site code and management point.
    6. Restarts the CcmExec service and triggers policy/inventory cycles.

    Every step is logged to a timestamped file for troubleshooting. Place this
    script alongside the ccmsetup binaries and run from that directory.

.PARAMETER SiteServer
    FQDN of the Configuration Manager site server (management point).

.PARAMETER SiteCode
    Three-letter site code (e.g. 'ABC').

.NOTES
    FileName : Invoke-MECMClientInstall.ps1
    Author   : Harry Caskey
    Created  : 2017-04-20
    Modified : 2026-03-20
    Version  : 2.0
    Requires : Administrator privileges, ccmsetup binaries in current directory
    Platform : Windows

.EXAMPLE
    PowerShell.exe -ExecutionPolicy Bypass ".\Invoke-MECMClientInstall.ps1" -SiteServer 'cm.corp.local' -SiteCode 'ABC'
    Runs a full client reinstall with logging.
#>

#Requires -RunAsAdministrator

[CmdletBinding()]
param(
    [Parameter(Mandatory, HelpMessage = 'FQDN of the CM management point')]
    [ValidateNotNullOrEmpty()]
    [string]$SiteServer,

    [Parameter(Mandatory, HelpMessage = 'Three-letter CM site code')]
    [ValidatePattern('^[A-Z0-9]{3}$')]
    [string]$SiteCode
)

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

# Set up logging
$logDir  = Join-Path $env:SystemRoot 'System32\LogFiles\OSD\CM-Client'
$logFile = Join-Path $logDir ('{0}_{1}.log' -f $env:COMPUTERNAME, (Get-Date -Format 'yyyyMMdd-HHmmss'))
New-Item -Path $logDir -ItemType Directory -Force | Out-Null

function Write-Log {
    param([string]$Message)
    $entry = "[$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')] $Message"
    $entry | Out-File -FilePath $logFile -Append -Encoding utf8
    Write-Output $entry
}

# --- Phase 1: Stop existing processes ---
Write-Log 'Phase 1 — Stopping Configuration Manager processes...'
foreach ($procName in @('CcmExec', 'ccmsetup', 'msiexec')) {
    Get-Process -Name $procName -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue
}
Start-Sleep -Seconds 5

# --- Phase 2: Uninstall ---
Write-Log 'Phase 2 — Running ccmsetup /uninstall...'
Start-Process -FilePath 'ccmsetup.exe' -ArgumentList '/uninstall' -Wait -WindowStyle Hidden
do { Start-Sleep -Seconds 10 } while (Get-Process -Name 'ccmsetup', 'msiexec' -ErrorAction SilentlyContinue)

# --- Phase 3: Clean up residual files and registry ---
Write-Log 'Phase 3 — Cleaning residual files and registry keys...'
$cleanupPaths = @(
    (Join-Path $env:SystemRoot 'CCM'),
    (Join-Path $env:SystemRoot 'ccmsetup'),
    (Join-Path $env:ProgramData 'Microsoft\Windows\Start Menu\Programs\Microsoft Endpoint Configuration Manager')
)
foreach ($path in $cleanupPaths) {
    if (Test-Path $path) {
        Remove-Item -Path $path -Recurse -Force -ErrorAction SilentlyContinue
        Write-Log "  Removed: $path"
    }
}
if (Test-Path 'HKLM:\SOFTWARE\Microsoft\CCMSetup') {
    Remove-Item -Path 'HKLM:\SOFTWARE\Microsoft\CCMSetup' -Force -ErrorAction SilentlyContinue
    Write-Log '  Removed: HKLM:\SOFTWARE\Microsoft\CCMSetup'
}

# --- Phase 4: Fresh install ---
Start-Sleep -Seconds 15
$installArgs = "/forceinstall /mp:$SiteServer INSTALL=ALL SMSSITECODE=$SiteCode /NoCRLCheck"
Write-Log "Phase 4 — Installing client: ccmsetup.exe $installArgs"
Start-Process -FilePath 'ccmsetup.exe' -ArgumentList $installArgs -Wait -WindowStyle Hidden
do { Start-Sleep -Seconds 10 } while (Get-Process -Name 'ccmsetup', 'msiexec' -ErrorAction SilentlyContinue)

# --- Phase 5: Post-install ---
Write-Log 'Phase 5 — Post-install: restarting service and triggering policy cycles...'
Start-Sleep -Seconds 120
Restart-Service -Name CcmExec -ErrorAction SilentlyContinue
Start-Sleep -Seconds 60

# Trigger standard policy and inventory schedules via CIM
$scheduleIDs = @(
    '{00000000-0000-0000-0000-000000000021}'   # Machine Policy Retrieval
    '{00000000-0000-0000-0000-000000000022}'   # Machine Policy Evaluation
    '{00000000-0000-0000-0000-000000000121}'   # Application Deployment Evaluation
    '{00000000-0000-0000-0000-000000000111}'   # State Message Refresh
    '{00000000-0000-0000-0000-000000000001}'   # Hardware Inventory
)
foreach ($id in $scheduleIDs) {
    Invoke-CimMethod -Namespace 'root\ccm' -ClassName 'SMS_CLIENT' -MethodName 'TriggerSchedule' `
        -Arguments @{ sScheduleID = $id } -ErrorAction SilentlyContinue | Out-Null
    Start-Sleep -Seconds 5
}

$ccmRunning = [bool](Get-Process -Name CcmExec -ErrorAction SilentlyContinue)
Write-Log "Complete — CcmExec running: $ccmRunning | Log: $logFile"

<#
.SYNOPSIS
    Registers Windows Photo Viewer in Windows 10/11.

.DESCRIPTION
    Microsoft hid the classic Windows Photo Viewer in Windows 10 in favor of the
    Photos app, but the DLL (PhotoViewer.dll) still exists. This script re-enables
    it by creating the necessary file-association registry entries under HKLM.

    After running:
    - Photo Viewer will appear in the "Open with" menu for image files.
    - You can set it as the default viewer via Settings > Default Apps.

    Supports common image formats: .jpg, .jpeg, .png, .bmp, .gif, .tif, .tiff,
    .ico, and .webp.

.NOTES
    FileName : Restore-WindowsPhotoViewer.ps1
    Author   : Harry Caskey
    Created  : 2016-04-06
    Modified : 2026-03-20
    Version  : 2.0
    Requires : Administrator privileges
    Platform : Windows 10 / Windows 11

.EXAMPLE
    .\Restore-WindowsPhotoViewer.ps1
    Registers Photo Viewer for all supported image extensions.
#>

#Requires -RunAsAdministrator

[CmdletBinding()]
param()

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

# The ProgId that maps to Windows Photo Viewer's file handler
$progId     = 'PhotoViewer.FileAssoc.Tiff'
$extensions = @('.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tif', '.tiff', '.ico', '.webp')
$assocPath  = 'HKLM:\SOFTWARE\Microsoft\Windows Photo Viewer\Capabilities\FileAssociations'

# Create the file associations path if it doesn't exist
if (-not (Test-Path $assocPath)) {
    New-Item -Path $assocPath -Force | Out-Null
}

# Register each extension with the Photo Viewer ProgId
foreach ($ext in $extensions) {
    Set-ItemProperty -Path $assocPath -Name $ext -Value $progId -Force
}

# Register Photo Viewer in the system's Registered Applications list
# This makes it appear in Default Apps settings
$regAppsPath = 'HKLM:\SOFTWARE\RegisteredApplications'
Set-ItemProperty -Path $regAppsPath -Name 'Windows Photo Viewer' `
    -Value 'SOFTWARE\Microsoft\Windows Photo Viewer\Capabilities' -Force

Write-Output "Windows Photo Viewer registered for: $($extensions -join ', ')"
Write-Output 'Open Settings > Default Apps to set it as your default image viewer.'

<#
.SYNOPSIS
    Prevents RDP session disconnects during Group Policy refresh.

.DESCRIPTION
    When Group Policy refreshes (gpupdate), it can momentarily delete the
    fDenyTSConnections registry value under the Terminal Server key. If an RDP
    session is active, this causes it to drop.

    This script sets fDenyTSConnections to 0 (allow connections), which persists
    through GPUpdate cycles and prevents the disconnect. It is a known issue
    documented in Microsoft KB 2083411.

    Run this on servers or workstations where RDP sessions need to remain stable
    during policy refresh windows.

    Reference: https://support.microsoft.com/kb/2083411

.NOTES
    FileName : Fix-GPUpdateRDPDisconnect.ps1
    Author   : Harry Caskey
    Created  : 2014-11-25
    Modified : 2026-03-20
    Version  : 2.0
    Requires : Administrator privileges
    Platform : Windows (any version with Terminal Services)

.EXAMPLE
    .\Fix-GPUpdateRDPDisconnect.ps1
    Sets fDenyTSConnections to 0, ensuring RDP stays connected during GPUpdate.
#>

#Requires -RunAsAdministrator

[CmdletBinding()]
param()

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

$regPath = 'HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server'

# Verify the registry path exists before attempting to set the value
if (-not (Test-Path $regPath)) {
    Write-Error "Terminal Server registry path not found: $regPath"
    return
}

# Set fDenyTSConnections to 0 — this tells Windows to allow Terminal Services connections
# The -Force flag ensures the value is created if it doesn't exist
Set-ItemProperty -Path $regPath -Name 'fDenyTSConnections' -Value 0 -Type DWord -Force

Write-Output 'fDenyTSConnections set to 0 — RDP sessions will survive Group Policy refresh.'

<#
.SYNOPSIS
    Fully disables IPv6 on all network adapters and at the OS level.

.DESCRIPTION
    Unchecking the IPv6 binding in adapter properties alone does not fully disable
    IPv6 — the tunnel adapters and loopback interface continue to operate. This script
    takes the complete approach:

    1. Disables the ms_tcpip6 binding on every network adapter.
    2. Sets the DisabledComponents registry value to 0xFF under the Tcpip6\Parameters
       key, which tells Windows to prefer IPv4 and disable all IPv6 components except
       the loopback.
    3. A reboot is required for the registry change to take full effect.

    Reference:
    https://learn.microsoft.com/en-us/troubleshoot/windows-server/networking/configure-ipv6-in-windows

.NOTES
    FileName : Disable-IPv6.ps1
    Author   : Harry Caskey
    Created  : 2014-10-07
    Modified : 2026-03-20
    Version  : 2.0
    Requires : Administrator privileges
    Platform : Windows 10/11, Server 2016+

.EXAMPLE
    .\Disable-IPv6.ps1
    Disables IPv6 binding on all adapters and sets the registry key.

.EXAMPLE
    .\Disable-IPv6.ps1 -WhatIf
    Shows what the script would do without making any changes.
#>

#Requires -RunAsAdministrator

[CmdletBinding(SupportsShouldProcess)]
param()

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

# Step 1 — Disable the IPv6 binding on every network adapter
if ($PSCmdlet.ShouldProcess('All network adapters', 'Disable IPv6 binding (ms_tcpip6)')) {
    Disable-NetAdapterBinding -Name '*' -ComponentID ms_tcpip6
    Write-Output 'IPv6 binding disabled on all adapters.'
}

# Step 2 — Set the registry key that tells Windows to fully disable IPv6 components
# 0xFF = disable all IPv6 components except the loopback interface, prefer IPv4 over IPv6
$regPath = 'HKLM:\SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters'

if ($PSCmdlet.ShouldProcess($regPath, 'Set DisabledComponents to 0xFF')) {
    if (-not (Test-Path $regPath)) {
        New-Item -Path $regPath -Force | Out-Null
    }
    Set-ItemProperty -Path $regPath -Name 'DisabledComponents' -Value 0xFF -Type DWord
    Write-Output 'Registry DisabledComponents set to 0xFF.'
}

Write-Warning 'A reboot is required for all IPv6 changes to take effect.'

<#
.SYNOPSIS
    Fixes the temporary profile installation error caused by MS14-049.

.DESCRIPTION
    After applying security update MS14-049, the Windows Installer service may block
    installations with the error: "The profile for the user is a temporary profile."

    This happens because the update introduced stricter repair policy checks. The fix
    is to set the SecureRepairPolicy registry value to 1 under the Windows Installer
    policy key, which relaxes the check and allows installations to proceed.

    Reference: https://support.microsoft.com/kb/2918614

.NOTES
    FileName : Fix-TemporaryProfileInstallError.ps1
    Author   : Harry Caskey
    Created  : 2014-10-06
    Modified : 2026-03-20
    Version  : 2.0
    Requires : Administrator privileges
    Platform : Windows 7+ / Server 2008 R2+

.EXAMPLE
    .\Fix-TemporaryProfileInstallError.ps1
    Creates the registry key if needed and sets SecureRepairPolicy to 1.
#>

#Requires -RunAsAdministrator

[CmdletBinding()]
param()

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

$regPath = 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\Installer'

# Create the registry path if it doesn't already exist
if (-not (Test-Path $regPath)) {
    New-Item -Path $regPath -Force | Out-Null
    Write-Verbose "Created registry path: $regPath"
}

# Set SecureRepairPolicy to 1 to allow installations under temporary profiles
Set-ItemProperty -Path $regPath -Name 'SecureRepairPolicy' -Value 1 -Type DWord

Write-Output 'SecureRepairPolicy set to 1 — Windows Installer temporary profile error resolved.'

<#
.SYNOPSIS
    Opens a new elevated (Administrator) PowerShell session.

.DESCRIPTION
    Checks if the current PowerShell session is running as Administrator using the
    Windows security principal API. If not, launches a new PowerShell window with
    the RunAs verb (UAC elevation prompt). If already elevated, reports the status
    instead of opening a redundant window.

    Quick utility for when you need elevation but don't want to right-click
    "Run as Administrator" in the Start menu.

.NOTES
    FileName : Start-ElevatedSession.ps1
    Author   : Harry Caskey
    Created  : 2014-07-17
    Modified : 2026-03-20
    Version  : 2.0
    Platform : Windows (PowerShell 5.1+)

.EXAMPLE
    .\Start-ElevatedSession.ps1
    Launches a new elevated PowerShell window (or reports if already elevated).
#>

[CmdletBinding()]
param()

Set-StrictMode -Version Latest

# Get the current user's security principal and check for Administrator role
$identity  = [Security.Principal.WindowsIdentity]::GetCurrent()
$principal = [Security.Principal.WindowsPrincipal]$identity
$isAdmin   = $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)

if ($isAdmin) {
    Write-Output 'This session is already running as Administrator.'
}
else {
    # Launch a new PowerShell process with elevation (triggers UAC prompt)
    Start-Process -FilePath 'PowerShell' -Verb RunAs
    Write-Output 'Elevated session launched — check the new window.'
}

<#
.SYNOPSIS
    Retrieves the BIOS serial number and model name from a local or remote machine.

.DESCRIPTION
    Queries CIM (Win32_BIOS and Win32_ComputerSystemProduct) for the device serial
    number and product model. Returns a clean object with ComputerName, SerialNumber,
    and Model properties.

    This replaces the old WMIC approach (wmic bios get serialnumber), which Microsoft
    has deprecated as of Windows 11. CIM cmdlets are the supported alternative and
    work both locally and remotely via WinRM.

.PARAMETER ComputerName
    The target machine name or IP. Defaults to the local computer. Supports pipeline
    input for querying multiple machines.

.NOTES
    FileName : Get-RemoteSerialNumber.ps1
    Author   : Harry Caskey
    Created  : 2012-09-13
    Modified : 2026-03-20
    Version  : 2.0
    Requires : WinRM enabled on remote targets
    Platform : Windows (PowerShell 5.1+)

.EXAMPLE
    .\Get-RemoteSerialNumber.ps1
    Returns the serial number and model of the local machine.

.EXAMPLE
    .\Get-RemoteSerialNumber.ps1 -ComputerName 'SERVER01'
    Queries a remote server.

.EXAMPLE
    'PC01', 'PC02', 'PC03' | .\Get-RemoteSerialNumber.ps1
    Queries multiple machines via pipeline input.
#>

[CmdletBinding()]
param(
    [Parameter(Position = 0, ValueFromPipeline)]
    [ValidateNotNullOrEmpty()]
    [string]$ComputerName = $env:COMPUTERNAME
)

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

    try {
        $bios  = Get-CimInstance -ClassName Win32_BIOS -ComputerName $ComputerName
        $model = Get-CimInstance -ClassName Win32_ComputerSystemProduct -ComputerName $ComputerName

        [PSCustomObject]@{
            ComputerName = $ComputerName
            SerialNumber = $bios.SerialNumber
            Model        = $model.Name
        }
    }
    catch {
        Write-Warning "Failed to query $ComputerName — $($_.Exception.Message)"
    }
}

<#
.SYNOPSIS
    Ensures the Configuration Manager client cache is set to the desired size.

.DESCRIPTION
    Queries the CM client CIM namespace (root\ccm\SoftMgmtAgent) for the current
    cache configuration. If the cache size does not match the specified value, the
    script updates it.

    This addresses the common issue where a CM client repair resets the cache back
    to the default 5120 MB (5 GB), which is too small for large application
    deployments. Run as a scheduled task or Group Policy startup script for
    continuous enforcement.

.PARAMETER SizeMB
    Desired cache size in megabytes. Defaults to 51200 (50 GB).

.NOTES
    FileName : Repair-MECMCacheSize.ps1
    Author   : Harry Caskey
    Created  : 2012-08-03
    Modified : 2026-03-20
    Version  : 2.0
    Requires : Configuration Manager client installed
    Platform : Windows

.EXAMPLE
    .\Repair-MECMCacheSize.ps1
    Sets the cache to the default 50 GB if it's different.

.EXAMPLE
    .\Repair-MECMCacheSize.ps1 -SizeMB 20480
    Sets the cache to 20 GB.
#>

[CmdletBinding()]
param(
    [ValidateRange(1024, 204800)]
    [int]$SizeMB = 51200
)

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

# Query the CM client cache configuration via CIM (replaces WMI)
$cache = Get-CimInstance -Namespace 'root\ccm\SoftMgmtAgent' -ClassName CacheConfig -ErrorAction Stop

if (-not $cache) {
    Write-Error 'Configuration Manager client cache configuration not found. Is the CM client installed?'
    return
}

if ($cache.Size -ne $SizeMB) {
    $cache | Set-CimInstance -Property @{ Size = $SizeMB; InUse = 'True' }
    Write-Output "Cache updated: $($cache.Size) MB -> $SizeMB MB"
}
else {
    Write-Output "Cache already set to $SizeMB MB — no change needed."
}

<#
.SYNOPSIS
    Formats a disk using native PowerShell storage cmdlets.

.DESCRIPTION
    Clears, initializes (GPT), partitions, and formats a disk — replacing the old
    manual DiskPart command-line workflow with native PowerShell cmdlets available
    in Windows 10/11 and Server 2016+.

    WARNING: This operation DESTROYS ALL DATA on the target disk. The ConfirmImpact
    is set to 'High', so PowerShell will prompt for confirmation. Use -WhatIf to
    preview the operation safely.

.PARAMETER DiskNumber
    The number of the disk to format (from Get-Disk output).

.PARAMETER FileSystem
    The file system to format with. Defaults to NTFS. Valid options: NTFS, ReFS,
    exFAT, FAT32.

.PARAMETER Label
    The volume label to assign. Defaults to 'Data'.

.NOTES
    FileName : Invoke-DiskPartFormat.ps1
    Author   : Harry Caskey
    Created  : 2012-07-29
    Modified : 2026-03-20
    Version  : 2.0
    Requires : Administrator privileges, Storage module
    Platform : Windows 10/11, Server 2016+

.EXAMPLE
    # First, list disks to find the right one
    Get-Disk | Format-Table Number, FriendlyName, Size, PartitionStyle

    # Then format disk 1
    .\Invoke-DiskPartFormat.ps1 -DiskNumber 1

.EXAMPLE
    .\Invoke-DiskPartFormat.ps1 -DiskNumber 2 -FileSystem ReFS -Label 'Archive' -Confirm:$false
    Formats disk 2 as ReFS without the confirmation prompt (use with caution).
#>

#Requires -RunAsAdministrator

[CmdletBinding(SupportsShouldProcess, ConfirmImpact = 'High')]
param(
    [Parameter(Mandatory, HelpMessage = 'Disk number from Get-Disk')]
    [ValidateRange(0, 99)]
    [int]$DiskNumber,

    [ValidateSet('NTFS', 'ReFS', 'exFAT', 'FAT32')]
    [string]$FileSystem = 'NTFS',

    [ValidateNotNullOrEmpty()]
    [string]$Label = 'Data'
)

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

# Verify the disk exists before proceeding
$disk = Get-Disk -Number $DiskNumber -ErrorAction Stop
$sizeGB = [math]::Round($disk.Size / 1GB, 1)

$target = "Disk $DiskNumber ($($disk.FriendlyName), $sizeGB GB)"

if ($PSCmdlet.ShouldProcess($target, 'Clear all data, re-initialize as GPT, partition, and format')) {
    # Clear removes all partitions and data
    Clear-Disk -Number $DiskNumber -RemoveData -RemoveOEM -Confirm:$false

    # Initialize as GPT (modern standard, supports >2TB, required for UEFI boot)
    Initialize-Disk -Number $DiskNumber -PartitionStyle GPT

    # Create a single partition using all available space and assign a drive letter
    $partition = New-Partition -DiskNumber $DiskNumber -UseMaximumSize -AssignDriveLetter

    # Format with the specified file system
    Format-Volume -Partition $partition -FileSystem $FileSystem -NewFileSystemLabel $Label -Confirm:$false

    Write-Output "Disk $DiskNumber formatted as $FileSystem with label '$Label' on drive $($partition.DriveLetter):"
}

<#
.SYNOPSIS
    Finds and removes disconnected mailboxes from an Exchange mailbox database.

.DESCRIPTION
    Queries an Exchange mailbox database for mailboxes that have a DisconnectDate
    (meaning the user account was deleted or the mailbox was disconnected). Lists
    the results and optionally removes them.

    Without the -RemoveAll switch, the script only lists disconnected mailboxes so
    you can review them first. With -RemoveAll and -WhatIf, you can preview the
    removal safely.

    Originally written for Exchange 2007. The same pattern works on Exchange 2010,
    2013, 2016, and 2019 — the cmdlets are the same.

.PARAMETER DatabaseName
    The name of the Exchange mailbox database to query.

.PARAMETER RemoveAll
    When specified, removes all disconnected mailboxes found. Without this switch,
    the script only lists them.

.NOTES
    FileName : Remove-DisconnectedMailbox.ps1
    Author   : Harry Caskey
    Created  : 2010-08-13
    Modified : 2026-03-20
    Version  : 2.0
    Requires : Exchange Management Shell
    Platform : Windows (Exchange Server environment)

.EXAMPLE
    .\Remove-DisconnectedMailbox.ps1 -DatabaseName 'Mailbox Database 01'
    Lists all disconnected mailboxes in the specified database.

.EXAMPLE
    .\Remove-DisconnectedMailbox.ps1 -DatabaseName 'Mailbox Database 01' -RemoveAll
    Removes all disconnected mailboxes (with confirmation prompts).
#>

[CmdletBinding(SupportsShouldProcess)]
param(
    [Parameter(Mandatory, HelpMessage = 'Name of the Exchange mailbox database')]
    [ValidateNotNullOrEmpty()]
    [string]$DatabaseName,

    [switch]$RemoveAll
)

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

# Query for mailboxes with a disconnect date
$disconnected = Get-MailboxStatistics -Database $DatabaseName |
                Where-Object { $null -ne $_.DisconnectDate } |
                Select-Object DisplayName, MailboxGuid, DisconnectDate

if (-not $disconnected) {
    Write-Output "No disconnected mailboxes found in '$DatabaseName'."
    return
}

Write-Output "Found $($disconnected.Count) disconnected mailbox(es) in '$DatabaseName':"
$disconnected | Format-Table DisplayName, MailboxGuid, DisconnectDate -AutoSize

if ($RemoveAll) {
    foreach ($mbx in $disconnected) {
        if ($PSCmdlet.ShouldProcess($mbx.DisplayName, 'Remove disconnected mailbox')) {
            Remove-Mailbox -Database $DatabaseName -StoreMailboxIdentity $mbx.MailboxGuid -Confirm:$false
            Write-Output "  Removed: $($mbx.DisplayName)"
        }
    }
}
else {
    Write-Output 'Use -RemoveAll to remove these mailboxes, or remove them individually with Remove-Mailbox.'
}

<#
.SYNOPSIS
    Recreates the OWA virtual directory on Exchange Server.

.DESCRIPTION
    Resolves the "Outlook Web Access did not initialize properly" error by removing
    the broken OWA virtual directory and creating a fresh one on the Default Web Site.

    This is a common issue after applying Cumulative Updates to the Client Access role
    or after IIS configuration changes. The fix is straightforward — delete and recreate.

    After running, an IIS reset (iisreset /noforce) is required.

    Originally written for Exchange 2007. The same cmdlets work on Exchange 2010, 2013,
    2016, and 2019.

.PARAMETER Server
    The Exchange server name to target.

.NOTES
    FileName : Repair-OWAVirtualDirectory.ps1
    Author   : Harry Caskey
    Created  : 2009-04-21
    Modified : 2026-03-20
    Version  : 2.0
    Requires : Exchange Management Shell
    Platform : Windows (Exchange Server environment)

.EXAMPLE
    .\Repair-OWAVirtualDirectory.ps1 -Server 'EXCH01'
    Removes and recreates the OWA virtual directory on EXCH01.

.EXAMPLE
    .\Repair-OWAVirtualDirectory.ps1 -Server 'EXCH01' -WhatIf
    Shows what the script would do without making changes.
#>

[CmdletBinding(SupportsShouldProcess)]
param(
    [Parameter(Mandatory, HelpMessage = 'Exchange server name')]
    [ValidateNotNullOrEmpty()]
    [string]$Server
)

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

$identity = "$Server\owa (Default Web Site)"

# Remove the broken virtual directory
if ($PSCmdlet.ShouldProcess($identity, 'Remove OWA virtual directory')) {
    Remove-OwaVirtualDirectory -Identity $identity -Confirm:$false -ErrorAction SilentlyContinue
    Write-Output 'OWA virtual directory removed.'
}

# Recreate it with default settings
if ($PSCmdlet.ShouldProcess("$Server - Default Web Site", 'Create new OWA virtual directory')) {
    New-OwaVirtualDirectory -WebSiteName 'Default Web Site' -Server $Server
    Write-Output 'OWA virtual directory recreated successfully.'
    Write-Output 'Run: iisreset /noforce — to restart IIS and apply the change.'
}

"""
Roman Numeral to Integer Converter

Classic algorithm problem — converts a Roman numeral string into its
integer value. Uses a reverse iteration approach which makes the
subtraction cases (like IV = 4, IX = 9) really clean to handle.

The trick: walk the string backwards. If the current numeral's value
is less than the one we just saw, it's a subtraction case (like the
I before V in "IV"), so we subtract. Otherwise, add.

Originally from a LeetCode study group session.
"""


def roman_to_int(s: str) -> int:
    # Map each Roman numeral character to its integer value
    roman_nums = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}

    prev_val = 0  # track the previous character's value as we iterate
    total = 0     # running total

    # Iterate the string in reverse (right to left)
    # This way, subtraction cases become obvious:
    #   "IX" reversed is "XI" — when we hit I (1) and prev was X (10),
    #   1 < 10 so we subtract instead of add
    for ch in s[::-1]:
        val = roman_nums[ch]

        if val < prev_val:
            # Subtraction case: I before V (IV=4), I before X (IX=9),
            # X before L (XL=40), X before C (XC=90), etc.
            total -= val
        else:
            # Normal case: just add the value
            total += val

        # Update previous value for the next iteration
        prev_val = val

    return total


if __name__ == '__main__':
    # Test cases covering basic numerals, subtraction pairs, and larger numbers
    test_cases = {
        'III': 3,        # simple addition: 1+1+1
        'IV': 4,         # subtraction: 5-1
        'IX': 9,         # subtraction: 10-1
        'XIV': 14,       # mixed: 10+(-1+5) = 14
        'XLII': 42,      # 40+2
        'MCMXCIV': 1994, # 1000+(1000-100)+(100-10)+(5-1)
        'MMXXVI': 2026,  # 1000+1000+10+10+5+1
    }

    for numeral, expected in test_cases.items():
        result = roman_to_int(numeral)
        status = 'PASS' if result == expected else 'FAIL'
        print(f'{status} | {numeral} -> {result} (expected {expected})')

"""
Bitcoin Price Checker

Grabs the current BTC/USD price from CoinGecko's free API and
compares it against a target value. Originally used the CoinDesk API
but that got deprecated, so switched to CoinGecko which is free
and doesn't require an API key.

A nice example of hitting a REST API, parsing JSON, and doing
something practical in a handful of lines.
"""

import requests


def get_btc_price() -> float:
    """
    Fetches the current Bitcoin price in USD from CoinGecko.
    Returns the price as a float.

    CoinGecko's /simple/price endpoint is free and rate-limited
    to ~30 calls/minute without an API key. Good enough for
    quick checks.
    """
    url = 'https://api.coingecko.com/api/v3/simple/price'

    # params: which coin(s) and which currency(ies) to convert to
    # you could add 'ethereum' to ids or 'eur' to vs_currencies
    # to get multiple results in one call
    params = {'ids': 'bitcoin', 'vs_currencies': 'usd'}

    # timeout prevents hanging forever if the API is down
    resp = requests.get(url, params=params, timeout=10)

    # raise_for_status() throws an exception on 4xx/5xx responses
    # so we don't silently proceed with bad data
    resp.raise_for_status()

    # response looks like: {"bitcoin": {"usd": 83456.00}}
    data = resp.json()

    return data['bitcoin']['usd']


if __name__ == '__main__':
    # set your target price here — whatever you're watching for
    target = 100_000.00

    # fetch the current price and compare
    price = get_btc_price()

    if price > target:
        print(f'BTC is ABOVE target: ${price:,.2f} (target: ${target:,.2f})')
    else:
        print(f'BTC is BELOW target: ${price:,.2f} (target: ${target:,.2f})')

"""
Palindrome Checker

Checks if an integer reads the same forwards and backwards.
Classic LeetCode problem (#9). The string reversal approach is
the most readable way to do it — convert to string, reverse it,
compare. Done.

Negatives are never palindromes because the minus sign means the
reversed string will always differ (e.g. "-121" reversed is "121-").
"""


def is_palindrome(x: int) -> bool:
    """
    Returns True if the integer x is a palindrome, False otherwise.

    Approach: convert to string and compare against its reverse.
    Python's slice notation s[::-1] reverses a string by stepping
    backwards through every character.

    Edge cases:
      - Negative numbers: always False (minus sign breaks symmetry)
      - Single digits (0-9): always True (1 char is trivially a palindrome)
    """
    # negative numbers can't be palindromes
    if x < 0:
        return False

    s = str(x)           # convert int to string: 121 -> "121"
    return s == s[::-1]   # compare "121" == "121" (reversed) -> True


if __name__ == '__main__':
    # test a mix of palindromes and non-palindromes
    test_values = [121, 1224221, -121, 10, 0, 12321, 123456]

    for val in test_values:
        result = is_palindrome(val)
        print(f'{val} -> {"palindrome" if result else "nope"}')

"""
Volcano Map Generator

Reads volcano data from a CSV file and plots them on an interactive
world map using Folium. Markers are color-coded by elevation:
  - Green: under 1500m
  - Orange: 1500-2500m
  - Red: above 2500m

Data source: Global Volcanism Program (Smithsonian Institution)
The Volcanoes.txt file has ~60 volcanoes with lat/lon coordinates,
elevation, type, and eruption status.

Uses the CartoDB dark_matter tileset for contrast, which makes the
colored markers easy to spot. The output is a standalone HTML file
you can open in any browser — no server needed.

Requires: pip install folium
"""

import csv
import folium


def load_volcanoes(filepath: str) -> list[dict]:
    """
    Parse the volcano CSV file and return a list of dictionaries.

    Each dict has: name, location, elev (meters), type, status, lat, lon.
    Rows with missing or malformed data get silently skipped — the CSV
    has some incomplete rows and this is cleaner than trying to fix them.
    """
    volcanoes = []

    with open(filepath, 'r', encoding='utf-8') as f:
        reader = csv.DictReader(f)  # first row becomes the column headers

        for row in reader:
            try:
                # pull out just the fields we care about
                volcanoes.append({
                    'name': row['NAME'],
                    'location': row['LOCATION'],
                    'elev': float(row['ELEV']),      # elevation in meters
                    'type': row['TYPE'],              # stratovolcano, shield, etc.
                    'status': row['STATUS'],          # historical, radiocarbon, etc.
                    'lat': float(row['LAT']),
                    'lon': float(row['LON']),
                })
            except (ValueError, KeyError):
                # skip rows that have bad data rather than crashing
                continue

    return volcanoes


def elev_color(elevation: float) -> str:
    """
    Pick a marker color based on the volcano's elevation.
    Higher elevations get warmer colors to stand out on the map.

    Under 1500m -> green  (lower elevation)
    1500-2500m  -> orange (moderate elevation)
    Over 2500m  -> red    (high elevation)
    """
    if elevation < 1500:
        return 'green'
    elif elevation < 2500:
        return 'orange'
    else:
        return 'red'


def build_map(volcanoes: list[dict]) -> folium.Map:
    """
    Creates a Folium map with circle markers for each volcano.

    Uses CartoDB dark_matter tiles (dark theme map) and adds markers
    to a FeatureGroup so they can be toggled on/off with the
    LayerControl widget.

    Each marker has a popup showing the volcano name, location,
    elevation, and type.
    """
    # center on roughly the middle of the world, zoomed out
    world = folium.Map(location=[15, 0], zoom_start=2, tiles='CartoDB dark_matter')

    # FeatureGroup lets us add a toggle for the volcano layer
    volcano_group = folium.FeatureGroup(name='Volcanoes')

    for v in volcanoes:
        # HTML popup content — shows on click
        popup_text = f"<b>{v['name']}</b><br>{v['location']}<br>{v['elev']:.0f}m - {v['type']}"

        # CircleMarker instead of regular Marker because it scales better
        # with lots of points and doesn't need icon images
        folium.CircleMarker(
            location=[v['lat'], v['lon']],
            radius=5,                              # marker size in pixels
            color=elev_color(v['elev']),            # border color
            fill=True,
            fill_opacity=0.7,
            popup=folium.Popup(popup_text, max_width=250),
        ).add_to(volcano_group)

    # add the group to the map and add a layer toggle
    volcano_group.add_to(world)
    folium.LayerControl().add_to(world)

    return world


if __name__ == '__main__':
    # load the data file (expects Volcanoes.txt in the same directory)
    volcanoes = load_volcanoes('Volcanoes.txt')
    print(f'Loaded {len(volcanoes)} volcanoes')

    # build the map and save it as a standalone HTML file
    m = build_map(volcanoes)
    m.save('volcano_map.html')
    print('Saved to volcano_map.html — open it in a browser')

"""
Cat Reactions

My cats have very specific reactions to things. This models their
behavior — show them something and they'll react based on what
category it falls into: food, play, love, or startle.

Originally part of a Flask web app where you could type things
into a form and get the cat's response. Pulled the core logic
out into its own module since it works standalone.

The reactions are all-caps because that's how cats communicate.
Loudly. Always. With great enthusiasm.
"""


class CatPersonality:
    """
    Models a cat's reaction to various stimuli.

    The REACTIONS dict organizes things the cat recognizes into
    categories. Each category has a list of trigger words and a
    response template. If the cat doesn't recognize something,
    it defaults to napping (which is most of the time, honestly).
    """

    # each category maps to a list of things the cat recognizes
    # and a response template with {thing} as a placeholder
    REACTIONS = {
        'food': {
            'triggers': ['wet food', 'dry food', 'treats'],
            'response': "OH BOY OH BOY! {thing} is my absolute favorite!!!",
        },
        'play': {
            'triggers': ['laser', 'bug', 'feather toy', 'crinkle ball'],
            'response': "MUST CHASE {thing}! This is the best game ever!!!",
        },
        'love': {
            'triggers': ['cuddles', 'belly rubs', 'pets', 'sleeping'],
            'response': "I LOVE THIS SO MUCH! Especially {thing}! Life is wonderful.",
        },
        'startle': {
            'triggers': ['loud noise', 'vacuum', 'doorbell'],
            'response': "WHAT WAS THAT?! {thing} scared me! I'll be under the blanket.",
        },
    }

    # if the cat doesn't recognize the thing, this is what you get
    DEFAULT_RESPONSE = "Hmm, not sure what that is. I'll be napping if you need me."

    def react(self, thing: str) -> str:
        """
        Show the cat something and get its reaction.

        Normalizes input to lowercase for matching, but keeps the
        original casing in the response. Everything gets uppercased
        at the end because cats yell everything.
        """
        thing_lower = thing.lower().strip()

        # check each category to see if the thing matches any triggers
        for category in self.REACTIONS.values():
            # case-insensitive comparison against all triggers
            if thing_lower in [t.lower() for t in category['triggers']]:
                # format the response with the thing and YELL IT
                return category['response'].format(thing=thing).upper()

        # cat doesn't know what this is — default to sleeping
        return self.DEFAULT_RESPONSE.upper()

    def list_known_things(self) -> list[str]:
        """Returns a flat list of everything the cat recognizes."""
        things = []
        for category in self.REACTIONS.values():
            things.extend(category['triggers'])
        return things


def interactive_mode():
    """
    Interactive loop — type things and see how the cat reacts.
    Type 'quit' to exit. Mostly useful for demo/fun.
    """
    cat = CatPersonality()
    print("=== Cat Reactions ===")
    print(f"Known things: {', '.join(cat.list_known_things())}")
    print("Type something to see how the cat reacts (or 'quit' to exit)\n")

    while True:
        user_input = input("Show the cat: ").strip()
        if user_input.lower() in ('quit', 'exit', 'q'):
            print("Cat is sleeping now. Bye.")
            break
        print(f"Cat says: {cat.react(user_input)}\n")


if __name__ == '__main__':
    # quick demo — run through a few things without interactive mode
    cat = CatPersonality()
    demo_things = ['Treats', 'Laser', 'Belly Rubs', 'Vacuum', 'a cardboard box']

    for thing in demo_things:
        print(f"  Show cat '{thing}' -> {cat.react(thing)}")

<#
.SYNOPSIS
    Interactive greeting with timestamp.
.DESCRIPTION
    Prompts for your name, returns a greeting with the current date and time.
    Simple but demonstrates Read-Host, Get-Date formatting, and string
    interpolation in PowerShell.

    If you pass -Name as a parameter it skips the prompt, which is
    handy for automation or piping.
.PARAMETER Name
    The name to greet. If omitted, the script prompts interactively.
.NOTES
    Author: Harry Caskey
    Platform: Cross-platform (PowerShell 5.1+)
.EXAMPLE
    .\Get-Greeting.ps1
    .\Get-Greeting.ps1 -Name "Harry"
#>

# CmdletBinding enables -Verbose, -Debug, etc. even on simple scripts
[CmdletBinding()]
param (
    # Position = 0 means you can just do: .\Get-Greeting.ps1 "Harry"
    # without explicitly typing -Name
    [Parameter(Position = 0)]
    [string]$Name
)

# if no name was passed as a parameter, ask for it
if (-not $Name) {
    $Name = Read-Host -Prompt 'Please specify your designation'
}

# format the date and time separately for clean output
# MM/dd/yyyy = US-style date format
$date = Get-Date -Format 'MM/dd/yyyy'

# HH = 24-hour clock, mm = minutes, ss = seconds
$time = Get-Date -Format 'HH:mm:ss'

# backtick-n (`n) is PowerShell's newline character inside double-quoted strings
# variables inside double quotes get expanded automatically (string interpolation)
Write-Output "`nHello, $Name. Welcome to the world!"
Write-Output "The date is $date and the current time is $time.`n"

<#
.SYNOPSIS
    Uninstall an application by name using the registry.
.DESCRIPTION
    Lists installed applications and uninstalls the one matching the
    provided name. Reads from the Windows registry instead of using the
    old Win32_Product WMI class.

    Why not Win32_Product? Because it triggers a consistency check on
    every single MSI package on the system, which is painfully slow
    and can actually cause side effects (like triggering repairs).
    The registry approach is instant and read-only.

    Supports -WhatIf and -Confirm through SupportsShouldProcess,
    so you can safely preview what would happen before actually
    uninstalling anything.
.PARAMETER AppName
    The display name (or partial name) of the application to uninstall.
    Uses wildcard matching so "Notepad" would match "Notepad++".
.PARAMETER ListOnly
    Just list installed applications without uninstalling anything.
    Good for browsing what's on the system.
.NOTES
    Author: Harry Caskey
    Platform: Windows
    Requires: Administrator privileges for uninstall operations
.EXAMPLE
    .\Uninstall-Application.ps1 -ListOnly
    .\Uninstall-Application.ps1 -AppName "Notepad++"
    .\Uninstall-Application.ps1 -AppName "Chrome" -WhatIf
#>

# SupportsShouldProcess enables -WhatIf and -Confirm parameters
[CmdletBinding(SupportsShouldProcess)]
param (
    [Parameter(Position = 0)]
    [string]$AppName,

    [switch]$ListOnly
)

function Get-InstalledApps {
    <#
    .SYNOPSIS
        Reads installed applications from the Windows registry.
    .DESCRIPTION
        Checks both the 64-bit and 32-bit (WOW6432Node) registry
        paths where Windows stores uninstall information for
        installed programs. Returns them sorted and deduplicated.
    #>

    # two registry locations: one for 64-bit apps, one for 32-bit (WOW6432Node)
    $registryPaths = @(
        'HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*',
        'HKLM:\Software\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*'
    )

    # loop through both paths and collect apps that have a display name
    $apps = foreach ($path in $registryPaths) {
        Get-ItemProperty -Path $path -ErrorAction SilentlyContinue |
            Where-Object { $_.DisplayName } |  # skip entries without names
            Select-Object DisplayName, DisplayVersion, Publisher, UninstallString
    }

    # sort alphabetically and remove duplicates (same app in both paths)
    $apps | Sort-Object DisplayName -Unique
}

# --- list mode: just show what's installed and exit ---
if ($ListOnly) {
    Get-InstalledApps | Format-Table -AutoSize
    return
}

# --- uninstall mode: need an app name ---
if (-not $AppName) {
    Write-Warning 'Specify -AppName "SomeApp" to uninstall, or use -ListOnly to browse.'
    return
}

# wildcard search — "Chrome" matches "Google Chrome", etc.
$matches = Get-InstalledApps | Where-Object { $_.DisplayName -like "*$AppName*" }

# no results
if (-not $matches) {
    Write-Warning "No installed application matching '$AppName' was found."
    return
}

# too many results — make the user be more specific to avoid accidents
if (($matches | Measure-Object).Count -gt 1) {
    Write-Warning "Multiple matches found for '$AppName'. Be more specific:"
    $matches | Format-Table DisplayName, DisplayVersion -AutoSize
    return
}

# exactly one match — proceed with uninstall
$app = $matches
Write-Output "Found: $($app.DisplayName) v$($app.DisplayVersion)"

# ShouldProcess generates the -WhatIf / -Confirm prompt
if ($PSCmdlet.ShouldProcess($app.DisplayName, 'Uninstall')) {
    $uninstallCmd = $app.UninstallString
    if ($uninstallCmd) {
        Write-Output "Running uninstaller..."
        # run the uninstall command through cmd.exe and wait for it to finish
        Start-Process cmd.exe -ArgumentList "/c `"$uninstallCmd`"" -Wait -NoNewWindow
        Write-Output "Done. You may need to restart."
    }
    else {
        Write-Warning "No uninstall command found for $($app.DisplayName)."
    }
}

<#
.SYNOPSIS
    Validates console color names against the System.ConsoleColor enum.
.DESCRIPTION
    Takes one or more color names and validates them against the
    System.ConsoleColor .NET enum. Returns the color name, its
    integer value, and a sample block.

    If you don't pass any colors, it shows all valid console colors.
    This is useful when building scripts that accept color parameters —
    you can validate input before passing it to Write-Host or other
    color-aware cmdlets.

    PowerShell does the validation automatically through the
    [System.ConsoleColor] type constraint on the parameter. If you
    pass an invalid color name, PowerShell throws an error before
    the script even runs. That's the point — let the type system
    do the work.
.PARAMETER Color
    One or more color names to validate. Defaults to all valid colors
    if you don't specify any.
.NOTES
    Author: Harry Caskey
    Platform: Cross-platform (PowerShell 5.1+)
.EXAMPLE
    .\Test-ConsoleColor.ps1 -Color Black, Red, Green
    .\Test-ConsoleColor.ps1
    .\Test-ConsoleColor.ps1 -Color "InvalidColor"  # throws validation error
#>

[CmdletBinding()]
param (
    # ValidateNotNullOrEmpty prevents $null or "" from getting through
    # [System.ConsoleColor[]] means PowerShell auto-validates against the enum
    # Default value grabs ALL valid colors from the enum if none specified
    [ValidateNotNullOrEmpty()]
    [System.ConsoleColor[]]$Color = [System.Enum]::GetValues([System.ConsoleColor])
)

# loop through each color and output a custom object with its details
foreach ($c in $Color) {
    # PSCustomObject creates a clean, formatted object for the pipeline
    [PSCustomObject]@{
        ColorName = $c.ToString()   # enum value as string: "Black", "Red", etc.
        Value     = [int]$c         # underlying integer: 0 for Black, 12 for Red, etc.
        Sample    = "██████"        # visual block — in a real terminal this would be colored
    }
}

# summary line at the end
Write-Output "`nTotal valid colors: $($Color.Count)"

<#
.SYNOPSIS
    Validates an IP address using .NET's System.Net.IPAddress class.
.DESCRIPTION
    Takes a string and validates whether it's a properly formatted
    IPv4 or IPv6 address. Uses the [System.Net.IPAddress]::Parse()
    method instead of regex.

    Why not regex? Because IP address regex is deceptively hard to
    get right — you'd need to handle leading zeros, IPv6 shorthand,
    mapped addresses, etc. The .NET class handles all of that already
    and is what PowerShell uses internally anyway.

    Returns a custom object with the input, whether it's valid,
    the address family (IPv4 vs IPv6), and the normalized form.
.PARAMETER IPAddress
    The IP address string to validate.
.NOTES
    Author: Harry Caskey
    Platform: Cross-platform (PowerShell 5.1+)
.EXAMPLE
    .\Test-IPAddress.ps1 -IPAddress 192.168.1.1
    .\Test-IPAddress.ps1 -IPAddress "::1"
    .\Test-IPAddress.ps1 -IPAddress "not.an.ip"
#>

[CmdletBinding()]
param (
    # Mandatory = must provide a value, Position = 0 lets you skip "-IPAddress"
    [Parameter(Mandatory, Position = 0)]
    [string]$IPAddress
)

try {
    # Parse() throws a FormatException if the string isn't a valid IP
    # This is cleaner than doing regex validation ourselves
    $parsed = [System.Net.IPAddress]::Parse($IPAddress)

    # output the parsed details as a structured object
    [PSCustomObject]@{
        Input         = $IPAddress
        Valid         = $true
        AddressFamily = $parsed.AddressFamily.ToString()  # InterNetwork (IPv4) or InterNetworkV6 (IPv6)
        Normalized    = $parsed.ToString()                 # cleaned-up form of the address
    }
}
catch {
    # Parse() failed — not a valid IP address
    # still output an object so the format is consistent
    [PSCustomObject]@{
        Input         = $IPAddress
        Valid         = $false
        AddressFamily = $null
        Normalized    = $null
    }
    Write-Warning "'$IPAddress' is not a valid IP address."
}