dir          - List directory contents
cd           - Change directory
copy         - Copy files
del          - Delete files
type         - Display file contents

Get-Date

Friday, June 5, 2026 2:38:15 PM

Get-ComputerInfo | Select-Object CsName, WindowsVersion, OsArchitecture

Get-Process | Sort-Object CPU -Descending | Select-Object -First 10

# Find all commands related to processes
Get-Command *Process*

# Get help for any command
Get-Help Get-Process

# See examples
Get-Help Get-Process -Examples

# View all properties of an object
Get-Process | Get-Member

# Find top 5 memory-consuming processes
Get-Process | 
    Sort-Object WorkingSet -Descending | 
    Select-Object -First 5 Name, @{Name="MemoryMB";Expression={[math]::Round($_.WorkingSet/1MB,2)}}

# Find all log files modified in last 7 days and compress them
Get-ChildItem -Path C:\Logs -Filter *.log -Recurse | 
    Where-Object {$_.LastWriteTime -gt (Get-Date).AddDays(-7)} | 
    Compress-Archive -DestinationPath "RecentLogs.zip"

# Run command on remote computer
Invoke-Command -ComputerName Server01 -ScriptBlock {Get-Service}

# Manage multiple servers at once
$servers = "Server01", "Server02", "Server03"
Invoke-Command -ComputerName $servers -ScriptBlock {
    Get-EventLog -LogName System -Newest 10
}

# These all do the same thing:
dir                    # DOS alias
ls                     # Linux alias
Get-ChildItem          # Full PowerShell cmdlet (RECOMMENDED)

# View all aliases
Get-Alias

# Find what a specific alias does
Get-Alias dir
Get-Alias ls

# DOS returns text, PowerShell returns objects
$processes = Get-Process

# Access properties directly
$processes[0].Name
$processes[0].CPU
$processes[0].WorkingSet

# Filter and sort easily
$processes | Where-Object {$_.CPU -gt 10} | Sort-Object CPU -Descending

# Chain commands together
Get-Process | 
    Where-Object {$_.WorkingSet -gt 100MB} |
    Sort-Object WorkingSet -Descending |
    Select-Object -First 10 Name, @{N="MemoryMB";E={[math]::Round($_.WorkingSet/1MB,2)}} |
    Export-Csv "TopProcesses.csv"

# Execute commands on remote computers
Invoke-Command -ComputerName Server01 -ScriptBlock {
    Get-Service | Where-Object {$_.Status -eq "Running"}
}

# Get processes from multiple computers
Get-Process -ComputerName Server01, Server02, Server03

# Proper error handling
try {
    Get-ChildItem C:\Windows\System32 -Recurse -ErrorAction Stop
}
catch {
    Write-Host "Error: $($_.Exception.Message)" -ForegroundColor Red
}

# Continue on errors
Get-ChildItem C:\Windows -Recurse -ErrorAction SilentlyContinue

# Install using winget (Windows 11/10)
winget install Microsoft.PowerShell

# Verify installation
pwsh --version

# Install using Chocolatey
choco install powershell-core -y

# Verify installation
pwsh --version

# Update package list
sudo apt-get update

# Install prerequisites
sudo apt-get install -y wget apt-transport-https software-properties-common

# Download Microsoft repository GPG keys
wget -q "https://packages.microsoft.com/config/ubuntu/$(lsb_release -rs)/packages-microsoft-prod.deb"

# Register the repository
sudo dpkg -i packages-microsoft-prod.deb

# Install PowerShell
sudo apt-get update
sudo apt-get install -y powershell

# Start PowerShell
pwsh

# Register Microsoft repository
curl https://packages.microsoft.com/config/rhel/8/prod.repo | sudo tee /etc/yum.repos.d/microsoft.repo

# Install PowerShell
sudo yum install -y powershell

# Start PowerShell
pwsh

# Install Homebrew if not already installed
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install PowerShell
brew install --cask powershell

# Start PowerShell
pwsh

# Check PowerShell version
$PSVersionTable

# Expected output:
# Name                           Value
# ----                           -----
# PSVersion                      7.5.0
# PSEdition                      Core
# GitCommitId                    7.5.0
# OS                             Microsoft Windows 10.0.22631
# Platform                       Win32NT
# PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0...}
# PSRemotingProtocolVersion      2.3
# SerializationVersion           1.1.0.1
# WSManStackVersion              3.0

# Check current execution policy
Get-ExecutionPolicy

# Check execution policy for all scopes
Get-ExecutionPolicy -List

# Set execution policy for current user (Recommended)
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

# Set execution policy for local machine (Requires Admin)
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope LocalMachine

# Check if profile exists
Test-Path $PROFILE

# View profile path
$PROFILE

# Create profile if it doesn't exist
if (!(Test-Path $PROFILE)) {
    New-Item -Path $PROFILE -ItemType File -Force
}

# Open profile in notepad
notepad $PROFILE

# Or open in VS Code (if installed)
code $PROFILE

# ============================================
# PowerShell Profile Configuration
# Author: Your Name
# Last Updated: June 2026
# ============================================

# --- Welcome Message ---
Write-Host "Welcome to PowerShell, $env:USERNAME!" -ForegroundColor Cyan
Write-Host "PowerShell Version: $($PSVersionTable.PSVersion)" -ForegroundColor Green
Write-Host "Today is: $(Get-Date -Format 'dddd, MMMM dd, yyyy')" -ForegroundColor Yellow
Write-Host ""

# --- Set Location ---
# Start in your preferred directory
Set-Location C:\Projects

# --- Custom Aliases ---
Set-Alias -Name np -Value notepad.exe
Set-Alias -Name vs -Value code
Set-Alias -Name ll -Value Get-ChildItem

# --- Custom Functions ---

# Quick directory listing with colors
function Get-DirectorySize {
    Get-ChildItem | 
    Select-Object Name, 
        @{Name="Size(MB)";Expression={[math]::Round($_.Length/1MB,2)}},
        LastWriteTime |
    Sort-Object "Size(MB)" -Descending
}
Set-Alias -Name lls -Value Get-DirectorySize

# Quick system information
function Get-QuickInfo {
    $os = Get-CimInstance Win32_OperatingSystem
    $cpu = Get-CimInstance Win32_Processor
    $mem = Get-CimInstance Win32_PhysicalMemory
    
    [PSCustomObject]@{
        ComputerName = $env:COMPUTERNAME
        OS = $os.Caption
        Version = $os.Version
        CPU = $cpu.Name
        Cores = $cpu.NumberOfCores
        RAM_GB = [math]::Round(($mem | Measure-Object Capacity -Sum).Sum / 1GB, 2)
        Uptime = (Get-Date) - $os.LastBootUpTime
    }
}
Set-Alias -Name sysinfo -Value Get-QuickInfo

# Quick network test
function Test-QuickConnection {
    param([string]$Target = "8.8.8.8")
    Test-Connection -ComputerName $Target -Count 2 -Quiet
}
Set-Alias -Name qping -Value Test-QuickConnection

# Open current directory in File Explorer
function Open-Explorer {
    explorer.exe .
}
Set-Alias -Name open -Value Open-Explorer

# --- Prompt Customization ---
function prompt {
    $location = Get-Location
    $time = Get-Date -Format "HH:mm:ss"
    
    Write-Host "[$time] " -NoNewline -ForegroundColor Gray
    Write-Host "$env:USERNAME" -NoNewline -ForegroundColor Green
    Write-Host "@" -NoNewline -ForegroundColor White
    Write-Host "$env:COMPUTERNAME" -NoNewline -ForegroundColor Cyan
    Write-Host " $location" -ForegroundColor Yellow
    Write-Host "PS>" -NoNewline -ForegroundColor Magenta
    return " "
}

# --- Module Auto-Import ---
# Import commonly used modules
$modules = @('PSReadLine', 'Posh-Git')
foreach ($module in $modules) {
    if (Get-Module -ListAvailable -Name $module) {
        Import-Module $module -ErrorAction SilentlyContinue
    }
}

# --- PSReadLine Configuration (Enhanced Command Line) ---
if (Get-Module -ListAvailable -Name PSReadLine) {
    # Prediction settings
    Set-PSReadLineOption -PredictionSource History
    Set-PSReadLineOption -PredictionViewStyle ListView
    
    # Colors
    Set-PSReadLineOption -Colors @{
        Command = 'Green'
        Parameter = 'Gray'
        String = 'Yellow'
    }
    
    # Key bindings
    Set-PSReadLineKeyHandler -Key UpArrow -Function HistorySearchBackward
    Set-PSReadLineKeyHandler -Key DownArrow -Function HistorySearchForward
    Set-PSReadLineKeyHandler -Key Tab -Function MenuComplete
}

# --- Environment Variables ---
$env:EDITOR = "code"  # Default editor

# --- Completion ---
# Enable tab completion for common commands
Register-ArgumentCompleter -CommandName Get-Service -ParameterName Name -ScriptBlock {
    param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameters)
    Get-Service "$wordToComplete*" | ForEach-Object {
        [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ParameterValue', $_.Name)
    }
}

Write-Host "Profile loaded successfully!" -ForegroundColor Green
Write-Host "Type 'Get-Command -Module $($MyInvocation.MyCommand.Module)' to see custom commands" -ForegroundColor Gray
Write-Host ""

# Reload your profile
. $PROFILE

# Or create a function in your profile to reload it
function Reload-Profile {
    . $PROFILE
    Write-Host "Profile reloaded!" -ForegroundColor Green
}

# List all installed modules
Get-Module -ListAvailable

# List currently loaded modules
Get-Module

# Find modules in PowerShell Gallery
Find-Module -Name "*Azure*"

# Get module information
Get-Module -Name PSReadLine -ListAvailable

# Install a module from PowerShell Gallery
Install-Module -Name PSReadLine -Scope CurrentUser

# Install specific version
Install-Module -Name Az -RequiredVersion 9.0.0 -Scope CurrentUser

# Install module with dependencies
Install-Module -Name Posh-Git -Scope CurrentUser -Force

# Update all installed modules
Update-Module

# Update specific module
Update-Module -Name PSReadLine

# Import a module
Import-Module -Name PSReadLine

# Remove a module from current session
Remove-Module -Name PSReadLine

# Uninstall a module
Uninstall-Module -Name OldModule

# List commands in a module
Get-Command -Module PSReadLine

# Get module path
$env:PSModulePath -split ';'

winget install Microsoft.VisualStudioCode

sudo snap install code --classic

brew install --cask visual-studio-code

{
    // PowerShell settings
    "powershell.powerShellDefaultVersion": "PowerShell (x64)",
    "powershell.integratedConsole.showOnStartup": false,
    "powershell.codeFormatting.preset": "OTBS",
    "powershell.codeFormatting.autoCorrectAliases": true,
    "powershell.codeFormatting.useCorrectCasing": true,
    
    // Editor settings
    "editor.fontSize": 14,
    "editor.fontFamily": "'Cascadia Code', 'Fira Code', Consolas, monospace",
    "editor.fontLigatures": true,
    "editor.minimap.enabled": true,
    "editor.rulers": [80, 120],
    "editor.renderWhitespace": "boundary",
    "editor.formatOnSave": true,
    
    // Terminal settings
    "terminal.integrated.fontSize": 13,
    "terminal.integrated.fontFamily": "'Cascadia Code', Consolas",
    "terminal.integrated.defaultProfile.windows": "PowerShell",
    
    // Files settings
    "files.autoSave": "afterDelay",
    "files.autoSaveDelay": 1000,
    "files.trimTrailingWhitespace": true,
    
    // Color theme (optional)
    "workbench.colorTheme": "PowerShell ISE",
    "workbench.iconTheme": "vs-seti"
}

# Install using winget
winget install Microsoft.WindowsTerminal

# Or install from Microsoft Store
# Search for "Windows Terminal"

{
    "defaultProfile": "{574e775e-4f2a-5b96-ac1e-a2962a402336}",
    "profiles": {
        "defaults": {
            "fontFace": "Cascadia Code PL",
            "fontSize": 11,
            "colorScheme": "One Half Dark",
            "useAcrylic": true,
            "acrylicOpacity": 0.9,
            "cursorShape": "bar"
        },
        "list": [
            {
                "guid": "{574e775e-4f2a-5b96-ac1e-a2962a402336}",
                "name": "PowerShell 7",
                "source": "Windows.Terminal.PowershellCore",
                "icon": "ms-appx:///ProfileIcons/{574e775e-4f2a-5b96-ac1e-a2962a402336}.png",
                "startingDirectory": "%USERPROFILE%"
            }
        ]
    },
    "schemes": [
        {
            "name": "PowerShell Custom",
            "background": "#012456",
            "foreground": "#CCCCCC",
            "black": "#0C0C0C",
            "blue": "#0037DA",
            "cyan": "#3A96DD",
            "green": "#13A10E",
            "purple": "#881798",
            "red": "#C50F1F",
            "white": "#CCCCCC",
            "yellow": "#C19C00",
            "brightBlack": "#767676",
            "brightBlue": "#3B78FF",
            "brightCyan": "#61D6D6",
            "brightGreen": "#16C60C",
            "brightPurple": "#B4009E",
            "brightRed": "#E74856",
            "brightWhite": "#F2F2F2",
            "brightYellow": "#F9F1A5"
        }
    ]
}

# Update help files (run once, requires internet and admin rights)
Update-Help -Force -ErrorAction SilentlyContinue

# Get help for a command
Get-Help Get-Process

# Get detailed help with examples
Get-Help Get-Process -Detailed

# Get full help including technical details
Get-Help Get-Process -Full

# Get only examples
Get-Help Get-Process -Examples

# Get help online (opens browser with latest documentation)
Get-Help Get-Process -Online

# Search for commands containing a keyword
Get-Help *process*

# Get help about PowerShell concepts
Get-Help about_Variables
Get-Help about_Operators
Get-Help about_Pipelines

# Find all available commands
Get-Command

# Find commands with specific verb
Get-Command -Verb Get

# Find commands with specific noun
Get-Command -Noun Process

# Find commands in a specific module
Get-Command -Module Microsoft.PowerShell.Management

# Search for commands by name pattern
Get-Command *service*

# Get detailed information about a command
Get-Command Get-Process | Format-List *

# Find all aliases
Get-Alias

# Find what command an alias represents
Get-Alias dir
Get-Alias ls

# Get current location
Get-Location
pwd  # Alias

# Change directory
Set-Location C:\Windows
cd C:\Windows  # Alias

# Go to parent directory
Set-Location ..
cd ..

# Go to home directory
Set-Location ~
cd ~

# Go back to previous location
Set-Location -

# Push location onto stack (save for later)
Push-Location C:\Temp

# Pop location from stack (return to saved location)
Pop-Location

# List files in current directory
Get-ChildItem
dir  # Alias
ls   # Alias

# List files with specific extension
Get-ChildItem *.txt

# List files recursively
Get-ChildItem -Recurse

# List hidden files
Get-ChildItem -Force

# List only directories
Get-ChildItem -Directory

# List only files
Get-ChildItem -File

# List with detailed properties
Get-ChildItem | Format-Table Name, Length, LastWriteTime

# Find large files (over 100MB)
Get-ChildItem -Recurse | Where-Object {$_.Length -gt 100MB} | 
    Sort-Object Length -Descending |
    Select-Object Name, @{Name="SizeMB";Expression={[math]::Round($_.Length/1MB,2)}}

# Create a new directory
New-Item -ItemType Directory -Path "C:\Temp\MyFolder"
mkdir "C:\Temp\MyFolder"  # Alias

# Create a new file
New-Item -ItemType File -Path "C:\Temp\test.txt"

# Copy a file
Copy-Item "C:\Temp\test.txt" "C:\Temp\test_backup.txt"
copy "C:\Temp\test.txt" "C:\Temp\test_backup.txt"  # Alias

# Copy a directory recursively
Copy-Item "C:\Temp\MyFolder" "C:\Temp\MyFolder_Backup" -Recurse

# Move a file
Move-Item "C:\Temp\test.txt" "C:\Temp\Archive\test.txt"
move "C:\Temp\test.txt" "C:\Temp\Archive\test.txt"  # Alias

# Rename a file
Rename-Item "C:\Temp\test.txt" "newname.txt"

# Delete a file
Remove-Item "C:\Temp\test.txt"
del "C:\Temp\test.txt"  # Alias

# Delete a directory and all contents
Remove-Item "C:\Temp\MyFolder" -Recurse -Force

# Delete files older than 30 days
Get-ChildItem "C:\Temp\*.log" | 
    Where-Object {$_.LastWriteTime -lt (Get-Date).AddDays(-30)} |
    Remove-Item

# Read entire file content
Get-Content "C:\Temp\test.txt"
cat "C:\Temp\test.txt"  # Alias

# Read first 10 lines
Get-Content "C:\Temp\test.txt" -TotalCount 10

# Read last 10 lines
Get-Content "C:\Temp\test.txt" -Tail 10

# Monitor file in real-time (like tail -f)
Get-Content "C:\Logs\app.log" -Wait -Tail 20

# Write to a file (overwrites)
"Hello World" | Out-File "C:\Temp\test.txt"
"Hello World" > "C:\Temp\test.txt"  # Redirection operator

# Append to a file
"New line" | Out-File "C:\Temp\test.txt" -Append
"New line" >> "C:\Temp\test.txt"  # Redirection operator

# Write array to file
$data = @("Line 1", "Line 2", "Line 3")
$data | Out-File "C:\Temp\test.txt"

# Read CSV file
Import-Csv "C:\Temp\data.csv"

# Write to CSV file
$data | Export-Csv "C:\Temp\output.csv" -NoTypeInformation

# Check if file or directory exists
Test-Path "C:\Temp\test.txt"

# Check if it's a file
Test-Path "C:\Temp\test.txt" -PathType Leaf

# Check if it's a directory
Test-Path "C:\Temp" -PathType Container

# Use in conditional logic
if (Test-Path "C:\Temp\test.txt") {
    Write-Host "File exists"
} else {
    Write-Host "File does not exist"
}

# List all running processes
Get-Process

# Get specific process by name
Get-Process -Name "notepad"

# Get process by ID
Get-Process -Id 1234

# Get processes sorted by CPU usage
Get-Process | Sort-Object CPU -Descending | Select-Object -First 10

# Get processes sorted by memory usage
Get-Process | Sort-Object WS -Descending | Select-Object -First 10

# Get detailed process information
Get-Process | Select-Object Name, Id, CPU, 
    @{Name="MemoryMB";Expression={[math]::Round($_.WS/1MB,2)}}

# Find processes using more than 100MB of memory
Get-Process | Where-Object {$_.WS -gt 100MB} | 
    Sort-Object WS -Descending

# Start a process
Start-Process "notepad.exe"

# Start a process with arguments
Start-Process "notepad.exe" -ArgumentList "C:\Temp\test.txt"

# Start a process as administrator
Start-Process "powershell.exe" -Verb RunAs

# Start a process and wait for it to complete
Start-Process "notepad.exe" -Wait

# Stop a process by name
Stop-Process -Name "notepad"

# Stop a process by ID
Stop-Process -Id 1234

# Stop all instances of a process
Get-Process -Name "notepad" | Stop-Process

# Stop a process forcefully
Stop-Process -Name "notepad" -Force

# Stop processes using more than 500MB RAM
Get-Process | Where-Object {$_.WS -gt 500MB} | Stop-Process -Force

# Monitor CPU usage and alert if high
$threshold = 80
$process = Get-Process | Sort-Object CPU -Descending | Select-Object -First 1
if ($process.CPU -gt $threshold) {
    Write-Warning "High CPU usage detected: $($process.Name) using $($process.CPU)%"
}

# Monitor memory usage
$totalMemory = (Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory
$freeMemory = (Get-CimInstance Win32_OperatingSystem).FreePhysicalMemory * 1KB
$usedMemoryPercent = [math]::Round((($totalMemory - $freeMemory) / $totalMemory) * 100, 2)
Write-Host "Memory Usage: $usedMemoryPercent%"

# List all services
Get-Service

# Get specific service
Get-Service -Name "wuauserv"  # Windows Update service

# Get running services
Get-Service | Where-Object {$_.Status -eq "Running"}

# Get stopped services
Get-Service | Where-Object {$_.Status -eq "Stopped"}

# Get services with specific display name pattern
Get-Service | Where-Object {$_.DisplayName -like "*Windows*"}

# Get service details
Get-Service -Name "wuauserv" | Format-List *

# Get services that can be stopped
Get-Service | Where-Object {$_.CanStop -eq $true}

# Start a service
Start-Service -Name "wuauserv"

# Stop a service
Stop-Service -Name "wuauserv"

# Restart a service
Restart-Service -Name "wuauserv"

# Start multiple services
Start-Service -Name "wuauserv", "BITS"

# Stop a service and its dependencies
Stop-Service -Name "wuauserv" -Force

# Set service startup type
Set-Service -Name "wuauserv" -StartupType Automatic
# Options: Automatic, Manual, Disabled

# Start a service and set startup type
Set-Service -Name "wuauserv" -StartupType Automatic -Status Running

# Check if critical services are running
$criticalServices = @("wuauserv", "BITS", "EventLog")
foreach ($service in $criticalServices) {
    $status = (Get-Service -Name $service).Status
    if ($status -ne "Running") {
        Write-Warning "Service $service is $status"
        # Optionally start the service
        # Start-Service -Name $service
    } else {
        Write-Host "Service $service is running" -ForegroundColor Green
    }
}

# Get services that failed to start
Get-Service | Where-Object {$_.Status -eq "Stopped" -and $_.StartType -eq "Automatic"}

# Get comprehensive computer information (Windows 10/Server 2016+)
Get-ComputerInfo

# Get specific properties
Get-ComputerInfo | Select-Object CsName, OsName, OsVersion, OsArchitecture

# Get computer name
$env:COMPUTERNAME
hostname

# Get operating system information
Get-CimInstance -ClassName Win32_OperatingSystem | 
    Select-Object Caption, Version, BuildNumber, OSArchitecture, 
    @{Name="InstallDate";Expression={$_.ConvertToDateTime($_.InstallDate)}},
    @{Name="LastBootUpTime";Expression={$_.ConvertToDateTime($_.LastBootUpTime)}}

# Calculate system uptime
$os = Get-CimInstance -ClassName Win32_OperatingSystem
$uptime = (Get-Date) - $os.LastBootUpTime
Write-Host "System Uptime: $($uptime.Days) days, $($uptime.Hours) hours, $($uptime.Minutes) minutes"

# Get BIOS information
Get-CimInstance -ClassName Win32_BIOS

# Get processor information
Get-CimInstance -ClassName Win32_Processor | 
    Select-Object Name, NumberOfCores, NumberOfLogicalProcessors, MaxClockSpeed

# Get memory information
Get-CimInstance -ClassName Win32_PhysicalMemory | 
    Select-Object Manufacturer, Capacity, Speed, DeviceLocator

# Total physical memory
$totalMemoryGB = [math]::Round((Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB, 2)
Write-Host "Total Physical Memory: $totalMemoryGB GB"

# Get disk information
Get-CimInstance -ClassName Win32_LogicalDisk | 
    Where-Object {$_.DriveType -eq 3} |
    Select-Object DeviceID, 
        @{Name="SizeGB";Expression={[math]::Round($_.Size/1GB,2)}},
        @{Name="FreeSpaceGB";Expression={[math]::Round($_.FreeSpace/1GB,2)}},
        @{Name="UsedSpaceGB";Expression={[math]::Round(($_.Size - $_.FreeSpace)/1GB,2)}},
        @{Name="PercentFree";Expression={[math]::Round(($_.FreeSpace/$_.Size)*100,2)}}

# Get network adapter information
Get-CimInstance -ClassName Win32_NetworkAdapter | 
    Where-Object {$_.PhysicalAdapter -eq $true} |
    Select-Object Name, MACAddress, Speed

# Comprehensive system information report
$report = @()

# Computer Info
$computerInfo = Get-ComputerInfo
$report += "=== COMPUTER INFORMATION ==="
$report += "Computer Name: $($computerInfo.CsName)"
$report += "OS: $($computerInfo.OsName)"
$report += "Version: $($computerInfo.OsVersion)"
$report += "Architecture: $($computerInfo.OsArchitecture)"
$report += ""

# CPU Info
$cpu = Get-CimInstance -ClassName Win32_Processor
$report += "=== PROCESSOR ==="
$report += "Name: $($cpu.Name)"
$report += "Cores: $($cpu.NumberOfCores)"
$report += "Logical Processors: $($cpu.NumberOfLogicalProcessors)"
$report += ""

# Memory Info
$totalMemoryGB = [math]::Round((Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB, 2)
$report += "=== MEMORY ==="
$report += "Total Physical Memory: $totalMemoryGB GB"
$report += ""

# Disk Info
$report += "=== DISK SPACE ==="
Get-CimInstance -ClassName Win32_LogicalDisk | 
    Where-Object {$_.DriveType -eq 3} | 
    ForEach-Object {
        $report += "Drive $($_.DeviceID): $([math]::Round($_.FreeSpace/1GB,2)) GB free of $([math]::Round($_.Size/1GB,2)) GB"
    }

# Output report
$report | Out-File "C:\Temp\SystemReport.txt"
$report | ForEach-Object { Write-Host $_ }

# Ping a host (modern PowerShell way)
Test-Connection -ComputerName "google.com" -Count 4

# Quiet mode (returns true/false)
Test-Connection -ComputerName "google.com" -Quiet

# Test multiple hosts
Test-Connection -ComputerName "google.com", "microsoft.com", "github.com" -Count 2

# Test with specific timeout
Test-Connection -ComputerName "google.com" -Count 1 -TimeoutSeconds 2

# Advanced connection test (port testing)
Test-NetConnection -ComputerName "google.com" -Port 443

# Test with detailed information
Test-NetConnection -ComputerName "google.com" -InformationLevel Detailed

# Trace route
Test-NetConnection -ComputerName "google.com" -TraceRoute

# Get IP configuration
Get-NetIPAddress

# Get IPv4 addresses only
Get-NetIPAddress -AddressFamily IPv4

# Get IP configuration for specific adapter
Get-NetIPAddress | Where-Object {$_.InterfaceAlias -like "*Ethernet*"}

# Get network adapter information
Get-NetAdapter

# Get active network adapters
Get-NetAdapter | Where-Object {$_.Status -eq "Up"}

# Get detailed adapter information
Get-NetAdapter | Format-List *

# Get DNS client configuration
Get-DnsClientServerAddress

# Get routing table
Get-NetRoute

# Get default gateway
Get-NetRoute -DestinationPrefix "0.0.0.0/0"

# Resolve DNS name
Resolve-DnsName "google.com"

# Get A records only
Resolve-DnsName "google.com" -Type A

# Get MX records (mail servers)
Resolve-DnsName "google.com" -Type MX

# Get all DNS records
Resolve-DnsName "google.com" -Type ALL

# Use specific DNS server
Resolve-DnsName "google.com" -Server 8.8.8.8

# Clear DNS cache
Clear-DnsClientCache

# View DNS cache
Get-DnsClientCache

# Monitor multiple hosts
$hosts = @("google.com", "microsoft.com", "github.com")
$results = @()

foreach ($host in $hosts) {
    $ping = Test-Connection -ComputerName $host -Count 1 -Quiet
    $results += [PSCustomObject]@{
        Host = $host
        Status = if ($ping) { "Online" } else { "Offline" }
        Timestamp = Get-Date
    }
}

$results | Format-Table -AutoSize

# Continuous monitoring with alerts
while ($true) {
    $result = Test-Connection -ComputerName "google.com" -Count 1 -Quiet
    if (-not $result) {
        Write-Warning "Host google.com is unreachable at $(Get-Date)"
    }
    Start-Sleep -Seconds 60
}

# Get all local users
Get-LocalUser

# Get specific user
Get-LocalUser -Name "Administrator"

# Get enabled users
Get-LocalUser | Where-Object {$_.Enabled -eq $true}

# Create a new local user
$password = ConvertTo-SecureString "P@ssw0rd123" -AsPlainText -Force
New-LocalUser -Name "TestUser" -Password $password -FullName "Test User" -Description "Test account"

# Disable a user
Disable-LocalUser -Name "TestUser"

# Enable a user
Enable-LocalUser -Name "TestUser"

# Remove a user
Remove-LocalUser -Name "TestUser"

# Change user password
$newPassword = ConvertTo-SecureString "NewP@ssw0rd123" -AsPlainText -Force
Set-LocalUser -Name "TestUser" -Password $newPassword

# Get local groups
Get-LocalGroup

# Get members of a group
Get-LocalGroupMember -Group "Administrators"

# Add user to group
Add-LocalGroupMember -Group "Administrators" -Member "TestUser"

# Remove user from group
Remove-LocalGroupMember -Group "Administrators" -Member "TestUser"

# Get ACL (Access Control List) for a file or folder
Get-Acl "C:\Temp"

# Get detailed ACL information
Get-Acl "C:\Temp" | Format-List

# Get ACL and display access rules
(Get-Acl "C:\Temp").Access | Format-Table IdentityReference, FileSystemRights, AccessControlType

# Set ACL (copy permissions from one folder to another)
$acl = Get-Acl "C:\Temp"
Set-Acl "C:\Temp2" -AclObject $acl

# Add permission to a folder
$acl = Get-Acl "C:\Temp"
$permission = "DOMAIN\User", "FullControl", "ContainerInherit,ObjectInherit", "None", "Allow"
$accessRule = New-Object System.Security.AccessControl.FileSystemAccessRule $permission
$acl.SetAccessRule($accessRule)
Set-Acl "C:\Temp" -AclObject $acl

# Check if running as administrator
$isAdmin = ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)

if ($isAdmin) {
    Write-Host "Running as Administrator" -ForegroundColor Green
} else {
    Write-Host "NOT running as Administrator" -ForegroundColor Red
}

# Get current user
$env:USERNAME
[System.Security.Principal.WindowsIdentity]::GetCurrent().Name

# Get current date and time
Get-Date

# Format date
Get-Date -Format "yyyy-MM-dd"
Get-Date -Format "yyyy-MM-dd HH:mm:ss"
Get-Date -Format "dddd, MMMM dd, yyyy"

# Get specific date components
$date = Get-Date
$date.Year
$date.Month
$date.Day
$date.Hour
$date.Minute
$date.DayOfWeek

# Date arithmetic
$today = Get-Date
$yesterday = $today.AddDays(-1)
$nextWeek = $today.AddDays(7)
$lastMonth = $today.AddMonths(-1)
$nextYear = $today.AddYears(1)

# Calculate date difference
$startDate = Get-Date "2024-01-01"
$endDate = Get-Date
$difference = $endDate - $startDate
Write-Host "Days since January 1, 2024: $($difference.Days)"

# Get files modified in last 7 days
Get-ChildItem "C:\Temp" | Where-Object {$_.LastWriteTime -gt (Get-Date).AddDays(-7)}

# Get all scheduled tasks
Get-ScheduledTask

# Get specific task
Get-ScheduledTask -TaskName "MyTask"

# Get running tasks
Get-ScheduledTask | Where-Object {$_.State -eq "Running"}

# Get task information
Get-ScheduledTaskInfo -TaskName "MyTask"

# Create a new scheduled task
$action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File C:\Scripts\MyScript.ps1"
$trigger = New-ScheduledTaskTrigger -Daily -At 9am
Register-ScheduledTask -Action $action -Trigger $trigger -TaskName "MyDailyTask" -Description "Runs daily at 9 AM"

# Start a task manually
Start-ScheduledTask -TaskName "MyTask"

# Stop a running task
Stop-ScheduledTask -TaskName "MyTask"

# Disable a task
Disable-ScheduledTask -TaskName "MyTask"

# Enable a task
Enable-ScheduledTask -TaskName "MyTask"

# Remove a task
Unregister-ScheduledTask -TaskName "MyTask" -Confirm:$false

# Get available event logs
Get-EventLog -List

# Get recent entries from System log
Get-EventLog -LogName System -Newest 10

# Get recent entries from Application log
Get-EventLog -LogName Application -Newest 10

# Get error entries only
Get-EventLog -LogName System -EntryType Error -Newest 20

# Get events from specific source
Get-EventLog -LogName Application -Source "Application Error" -Newest 10

# Get events after specific date
Get-EventLog -LogName System -After (Get-Date).AddDays(-7)

# Modern way using Get-WinEvent (more powerful)
Get-WinEvent -LogName System -MaxEvents 10

# Filter by event ID
Get-WinEvent -FilterHashtable @{LogName='System'; ID=1074}

# Get events from last 24 hours
Get-WinEvent -FilterHashtable @{
    LogName='System'
    Level=2  # Error
    StartTime=(Get-Date).AddDays(-1)
}

# Search event message content
Get-WinEvent -LogName System -MaxEvents 100 | 
    Where-Object {$_.Message -like "*disk*"}

# Analyze system errors from last 7 days
$startDate = (Get-Date).AddDays(-7)
$errors = Get-WinEvent -FilterHashtable @{
    LogName='System'
    Level=2  # Error
    StartTime=$startDate
}

# Group by source
$errorsBySource = $errors | Group-Object ProviderName | 
    Sort-Object Count -Descending |
    Select-Object Count, Name

Write-Host "Error Summary (Last 7 Days):" -ForegroundColor Yellow
$errorsBySource | Format-Table -AutoSize

# Get critical events
$critical = Get-WinEvent -FilterHashtable @{
    LogName='System'
    Level=1  # Critical
    StartTime=$startDate
}

if ($critical) {
    Write-Host "`nCritical Events Found: $($critical.Count)" -ForegroundColor Red
    $critical | Select-Object TimeCreated, ProviderName, Message | Format-List
}

# Valid variable names
$userName = "John"
$user_age = 30
$serverIP = "192.168.1.1"
$isActive = $true
$counter1 = 0

# Invalid variable names (will cause errors)
# userName = "John"      # Missing $
# $user-name = "John"    # Hyphens not allowed
# $1counter = 0          # Cannot start with number

# Simple assignment
$name = "Alice"
$age = 25
$salary = 50000.50

# Display variable values
Write-Host "Name: $name"
Write-Host "Age: $age"
Write-Host "Salary: $salary"

# Multiple assignments
$x = $y = $z = 0

# Reassigning variables
$counter = 1
$counter = 2
$counter = "Now I'm a string!"  # Type can change

# Get the type of a variable
$name = "John"
$name.GetType()

# More detailed type information
$age = 30
$age.GetType().FullName    # System.Int32

# Check if variable is of specific type
$value = 42
$value -is [int]           # Returns True
$value -is [string]        # Returns False

# Display type in readable format
$salary = 50000.50
Write-Host "Type: $($salary.GetType().Name)"  # Double

# Double quotes - Variables are expanded
$name = "Alice"
$greeting = "Hello, $name!"
Write-Host $greeting  # Output: Hello, Alice!

# Single quotes - Literal string (no variable expansion)
$greeting2 = 'Hello, $name!'
Write-Host $greeting2  # Output: Hello, $name!

# Escape characters in double quotes
$path = "C:\Users\John\Documents"
$quote = "He said, \"Hello\""

# Here-strings for multi-line text
$multiLine = @"
This is line 1
This is line 2
Variables work here: $name
"@

$literalMultiLine = @'
This is literal
$name will not expand
'@

# String concatenation
$firstName = "John"
$lastName = "Doe"
$fullName = $firstName + " " + $lastName
# Or using string interpolation
$fullName = "$firstName $lastName"

# String length
$text = "PowerShell"
$length = $text.Length  # 10

# String methods
$text = "  PowerShell Rocks!  "
$text.ToUpper()              # "  POWERSHELL ROCKS!  "
$text.ToLower()              # "  powershell rocks!  "
$text.Trim()                 # "PowerShell Rocks!"
$text.TrimStart()            # "PowerShell Rocks!  "
$text.TrimEnd()              # "  PowerShell Rocks!"

# Substring
$text = "PowerShell"
$text.Substring(0, 5)        # "Power"
$text.Substring(5)           # "Shell"

# Replace
$text = "Hello World"
$text.Replace("World", "PowerShell")  # "Hello PowerShell"

# Split
$csv = "John,Doe,30,Engineer"
$fields = $csv.Split(",")    # Creates array: @("John", "Doe", "30", "Engineer")

# Contains, StartsWith, EndsWith
$text = "PowerShell"
$text.Contains("Shell")      # True
$text.StartsWith("Power")    # True
$text.EndsWith("Python")     # False

# String formatting
$name = "Alice"
$age = 30
$formatted = "Name: {0}, Age: {1}" -f $name, $age
# Or using string interpolation
$formatted = "Name: $name, Age: $age"

# Integer operations
$a = 10
$b = 3

$sum = $a + $b          # 13
$difference = $a - $b   # 7
$product = $a * $b      # 30
$quotient = $a / $b     # 3.33333...
$remainder = $a % $b    # 1 (modulo)

# Increment and decrement
$counter = 0
$counter++              # 1
$counter += 5           # 6
$counter--              # 5
$counter -= 2           # 3

# Floating-point numbers
$pi = 3.14159
$radius = 5
$area = $pi * $radius * $radius

# Rounding
$value = 3.7
[Math]::Round($value)           # 4
[Math]::Floor($value)           # 3
[Math]::Ceiling($value)         # 4
[Math]::Round($value, 2)        # 3.70

# Other math operations
[Math]::Abs(-5)                 # 5
[Math]::Pow(2, 3)               # 8 (2^3)
[Math]::Sqrt(16)                # 4
[Math]::Max(10, 20)             # 20
[Math]::Min(10, 20)             # 10

# Converting between numeric types
$intValue = 42
$doubleValue = [double]$intValue
$stringValue = $intValue.ToString()

# Boolean literals
$isActive = $true
$isDeleted = $false

# Boolean from comparisons
$age = 25
$isAdult = $age -ge 18        # True

# Boolean operations
$a = $true
$b = $false

$and = $a -and $b             # False
$or = $a -or $b               # True
$not = -not $a                # False
$xor = $a -xor $b             # True

# Truthiness in PowerShell
# These evaluate to $false:
#   $false, $null, 0, "", @()
# Everything else evaluates to $true

if ($null) { "True" } else { "False" }     # False
if (0) { "True" } else { "False" }         # False
if ("") { "True" } else { "False" }        # False
if ("text") { "True" } else { "False" }    # True
if (1) { "True" } else { "False" }         # True

# Creating arrays
$colors = @("Red", "Green", "Blue")
$numbers = 1, 2, 3, 4, 5
$mixed = @(1, "two", 3.0, $true)
$empty = @()

# Accessing array elements (zero-based index)
$colors[0]              # "Red"
$colors[1]              # "Green"
$colors[-1]             # "Blue" (last element)
$colors[-2]             # "Green" (second to last)

# Array length
$count = $colors.Count  # 3
$count = $colors.Length # 3

# Array slicing
$numbers = 1, 2, 3, 4, 5
$numbers[0..2]          # 1, 2, 3
$numbers[2..4]          # 3, 4, 5
$numbers[0, 2, 4]       # 1, 3, 5

# Modifying arrays
$colors[0] = "Yellow"   # Change first element

# Adding to arrays (creates new array)
$colors = $colors + "Purple"
$colors += "Orange"

# Array contains
$colors -contains "Red"     # True or False
$colors -notcontains "Pink" # True or False

# Looping through arrays
$fruits = @("Apple", "Banana", "Cherry")

foreach ($fruit in $fruits) {
    Write-Host $fruit
}

# Using ForEach-Object
$fruits | ForEach-Object {
    Write-Host "I like $_"
}

# Filtering arrays
$numbers = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
$evenNumbers = $numbers | Where-Object { $_ % 2 -eq 0 }
# Result: 2, 4, 6, 8, 10

# Sorting arrays
$names = @("Charlie", "Alice", "Bob")
$sorted = $names | Sort-Object
# Result: Alice, Bob, Charlie

$numbers = 5, 2, 8, 1, 9
$sortedDesc = $numbers | Sort-Object -Descending
# Result: 9, 8, 5, 2, 1

# Selecting specific elements
$numbers = 1, 2, 3, 4, 5
$first3 = $numbers | Select-Object -First 3    # 1, 2, 3
$last2 = $numbers | Select-Object -Last 2      # 4, 5

# Joining array elements
$words = @("Power", "Shell", "Rocks")
$sentence = $words -join " "  # "Power Shell Rocks"
$csv = $words -join ","       # "Power,Shell,Rocks"

# Measuring arrays
$numbers = 1, 2, 3, 4, 5
$stats = $numbers | Measure-Object -Sum -Average -Maximum -Minimum
$stats.Sum        # 15
$stats.Average    # 3
$stats.Maximum    # 5
$stats.Minimum    # 1

# Creating hashtables
$person = @{
    Name = "John Doe"
    Age = 30
    City = "New York"
    IsEmployed = $true
}

# Accessing values
$person["Name"]           # "John Doe"
$person.Name              # "John Doe" (dot notation)
$person["Age"]            # 30

# Adding new keys
$person["Email"] = "[email protected]"
$person.Phone = "555-1234"

# Modifying values
$person["Age"] = 31
$person.City = "Boston"

# Removing keys
$person.Remove("Phone")

# Check if key exists
$person.ContainsKey("Name")     # True
$person.ContainsKey("Salary")   # False

# Get all keys and values
$person.Keys                    # Name, Age, City, IsEmployed, Email
$person.Values                  # John Doe, 31, Boston, True, [email protected]

# Count of items
$person.Count                   # 5

$server = @{
    Name = "WEB01"
    IP = "192.168.1.100"
    OS = "Windows Server 2022"
    RAM = "16GB"
}

# Loop through keys and values
foreach ($key in $server.Keys) {
    Write-Host "$key : $($server[$key])"
}

# Using GetEnumerator()
$server.GetEnumerator() | ForEach-Object {
    Write-Host "$($_.Key) = $($_.Value)"
}

# Ordered hashtables (maintains insertion order)
$orderedHash = [ordered]@{
    First = 1
    Second = 2
    Third = 3
}

# Nested hashtables
$company = @{
    Name = "TechCorp"
    Employees = @{
        CEO = "Alice"
        CTO = "Bob"
        CFO = "Charlie"
    }
    Revenue = 1000000
}

# Accessing nested values
$company.Employees.CEO          # "Alice"
$company["Employees"]["CTO"]    # "Bob"

# Explicit type casting
[int]$age = "30"              # String to Integer
[string]$number = 42          # Integer to String
[double]$price = "19.99"      # String to Double
[bool]$flag = 1               # Integer to Boolean

# Type declaration (enforces type)
[int]$count = 10
$count = "text"               # ERROR! Cannot convert string to int

# Converting strings to numbers
$text = "123"
$number = [int]$text          # 123
$number = [convert]::ToInt32($text)

# Converting to DateTime
$dateString = "2026-06-05"
$date = [datetime]$dateString
$date = Get-Date $dateString

# Converting arrays
$stringArray = "1", "2", "3"
$intArray = $stringArray | ForEach-Object { [int]$_ }

# Safe conversion with try/catch
$input = "abc"
try {
    $number = [int]$input
} catch {
    Write-Host "Cannot convert '$input' to integer"
    $number = 0
}

# Checking if conversion is possible
$value = "123"
$result = $value -as [int]
if ($result -ne $null) {
    Write-Host "Conversion successful: $result"
}

# Global scope - accessible everywhere
$global:companyName = "TechCorp"

# Script scope - accessible throughout the script
$script:version = "1.0"

# Local scope (default)
$localVar = "I'm local"

# Function demonstrating scope
function Test-Scope {
    # This creates a local variable
    $localVar = "Function local"
    
    # Access global variable
    Write-Host "Global: $global:companyName"
    
    # Access script variable
    Write-Host "Script: $script:version"
    
    # Access local variable
    Write-Host "Local: $localVar"
    
    # Modify global variable
    $global:companyName = "NewCorp"
}

Test-Scope

# After function execution
Write-Host $companyName  # "NewCorp" (global was modified)
Write-Host $localVar     # "I'm local" (function's local didn't affect this)

# Private scope example
$private:secret = "Hidden"

function Try-AccessSecret {
    Write-Host $secret  # Will be empty/null - private not inherited
}

# Using scope in scripts
# Script1.ps1
$script:config = @{
    Server = "localhost"
    Port = 8080
}

function Get-Config {
    return $script:config
}

function Set-ConfigValue {
    param($key, $value)
    $script:config[$key] = $value
}

# $_ - Current object in pipeline
1, 2, 3, 4, 5 | ForEach-Object {
    Write-Host "Number: $_"
}

Get-Process | Where-Object { $_.CPU -gt 10 }

# $PSVersionTable - PowerShell version
Write-Host "PowerShell Version: $($PSVersionTable.PSVersion)"
Write-Host "Edition: $($PSVersionTable.PSEdition)"

# $HOME - Home directory
Write-Host "Home: $HOME"
$documentsPath = "$HOME\Documents"

# $PWD - Current directory
Write-Host "Current directory: $PWD"

# $PSScriptRoot - Script directory (useful in scripts)
# Script: C:\Scripts\MyScript.ps1
$configFile = "$PSScriptRoot\config.json"
$logFile = "$PSScriptRoot\logs\app.log"

# $args - Function arguments
function Show-Arguments {
    Write-Host "Number of arguments: $($args.Count)"
    foreach ($arg in $args) {
        Write-Host "Argument: $arg"
    }
}

Show-Arguments "one" "two" "three"

# $error - Recent errors
Get-Process "NonExistentProcess" -ErrorAction SilentlyContinue
if ($error.Count -gt 0) {
    Write-Host "Last error: $($error[0].Exception.Message)"
}

# Clear error list
$error.Clear()

# $null - Testing for empty values
$value = $null
if ($value -eq $null) {
    Write-Host "Value is null"
}

# $PID - Current process ID
Write-Host "PowerShell PID: $PID"

# $Host - Host application information
Write-Host "Host Name: $($Host.Name)"
Write-Host "Host Version: $($Host.Version)"

# Addition
$sum = 10 + 5
Write-Host "Sum: $sum"  # Output: 15

# Subtraction
$difference = 10 - 5
Write-Host "Difference: $difference"  # Output: 5

# Multiplication
$product = 10 * 5
Write-Host "Product: $product"  # Output: 50

# Division
$quotient = 10 / 5
Write-Host "Quotient: $quotient"  # Output: 2

# Modulus (remainder)
$remainder = 10 % 3
Write-Host "Remainder: $remainder"  # Output: 1

# Combining operations
$result = (10 + 5) * 2 - 3
Write-Host "Result: $result"  # Output: 27

# Power (using .NET Math class)
$power = [Math]::Pow(2, 8)
Write-Host "2^8 = $power"  # Output: 256

# Square root
$sqrt = [Math]::Sqrt(16)
Write-Host "Square root of 16: $sqrt"  # Output: 4

# Rounding
$rounded = [Math]::Round(3.7)
Write-Host "Rounded: $rounded"  # Output: 4

# Ceiling and Floor
$ceiling = [Math]::Ceiling(3.2)
$floor = [Math]::Floor(3.8)
Write-Host "Ceiling: $ceiling, Floor: $floor"  # Output: 4, 3

# Absolute value
$abs = [Math]::Abs(-10)
Write-Host "Absolute: $abs"  # Output: 10

# Simple assignment
$counter = 0
Write-Host "Initial: $counter"  # Output: 0

# Increment using +=
$counter += 1
Write-Host "After +=: $counter"  # Output: 1

# Add 5
$counter += 5
Write-Host "After += 5: $counter"  # Output: 6

# Multiply by 2
$counter *= 2
Write-Host "After *=: $counter"  # Output: 12

# Divide by 3
$counter /= 3
Write-Host "After /=: $counter"  # Output: 4

# Subtract 2
$counter -= 2
Write-Host "After -=: $counter"  # Output: 2

# Numeric comparisons
$a = 10
$b = 20

Write-Host "10 -eq 20: $($a -eq $b)"    # False
Write-Host "10 -ne 20: $($a -ne $b)"    # True
Write-Host "10 -lt 20: $($a -lt $b)"    # True
Write-Host "10 -gt 20: $($a -gt $b)"    # False
Write-Host "10 -le 10: $($a -le 10)"    # True
Write-Host "10 -ge 10: $($a -ge 10)"    # True

# String comparisons (case-insensitive by default)
$name1 = "PowerShell"
$name2 = "powershell"

Write-Host "'PowerShell' -eq 'powershell': $($name1 -eq $name2)"  # True

# Case-sensitive comparison
Write-Host "'PowerShell' -ceq 'powershell': $($name1 -ceq $name2)"  # False

# AND operator - both conditions must be true
$age = 25
$hasLicense = $true

if ($age -ge 18 -and $hasLicense) {
    Write-Host "Can drive"
} else {
    Write-Host "Cannot drive"
}

# OR operator - at least one condition must be true
$isWeekend = $false
$isHoliday = $true

if ($isWeekend -or $isHoliday) {
    Write-Host "Day off!"
} else {
    Write-Host "Work day"
}

# NOT operator - inverts the boolean value
$isRaining = $false
if (-not $isRaining) {
    Write-Host "Go for a walk"
}

# XOR operator - true if conditions are different
$option1 = $true
$option2 = $false

if ($option1 -xor $option2) {
    Write-Host "Exactly one option is selected"
}

# Complex logical expression
$temperature = 25
$isSunny = $true
$hasUmbrella = $false

if (($temperature -gt 20 -and $isSunny) -or $hasUmbrella) {
    Write-Host "Good weather for outdoor activity"
}

# * matches zero or more characters
$filename = "report.txt"
Write-Host "$filename -like '*.txt': $($filename -like '*.txt')"  # True
Write-Host "$filename -like 'report*': $($filename -like 'report*')"  # True
Write-Host "$filename -like '*port*': $($filename -like '*port*')"  # True

# ? matches exactly one character
$code = "ABC123"
Write-Host "$code -like 'ABC???': $($code -like 'ABC???')"  # True
Write-Host "$code -like 'ABC??': $($code -like 'ABC??')"  # False

# [abc] matches any character in the set
$letter = "b"
Write-Host "$letter -like '[abc]': $($letter -like '[abc]')"  # True

# Filter files
$files = @("report.txt", "data.csv", "notes.txt", "image.png")
$textFiles = $files | Where-Object { $_ -like "*.txt" }
Write-Host "Text files: $($textFiles -join ', ')"

# Match digits
$text = "Order number: 12345"
if ($text -match "\d+") {
    Write-Host "Contains numbers: $($matches[0])"  # Output: 12345
}

# Match email pattern
$email = "[email protected]"
$emailPattern = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
if ($email -match $emailPattern) {
    Write-Host "Valid email format"
}

# Extract date from string
$log = "Error occurred on 2026-06-05 at 15:30"
if ($log -match "(\d{4}-\d{2}-\d{2})") {
    $date = $matches[1]
    Write-Host "Date extracted: $date"  # Output: 2026-06-05
}

# Match IP address
$ip = "192.168.1.1"
$ipPattern = "^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$"
if ($ip -match $ipPattern) {
    Write-Host "Valid IP format"
}

# Replace text
$text = "Hello World"
$newText = $text -replace "World", "PowerShell"
Write-Host $newText  # Output: Hello PowerShell

# Replace using regex
$phone = "123-456-7890"
$cleanPhone = $phone -replace "-", ""
Write-Host $cleanPhone  # Output: 1234567890

# Replace multiple spaces with single space
$messyText = "Too    many     spaces"
$cleanText = $messyText -replace "\s+", " "
Write-Host $cleanText  # Output: Too many spaces

# Split string
$csv = "John,Doe,30,Engineer"
$fields = $csv -split ","
Write-Host "First name: $($fields[0])"
Write-Host "Last name: $($fields[1])"
Write-Host "Age: $($fields[2])"
Write-Host "Job: $($fields[3])"

# Split by multiple delimiters
$data = "apple;banana,orange;grape"
$fruits = $data -split "[;,]"
Write-Host "Fruits: $($fruits -join ', ')"

# Join array elements
$words = @("PowerShell", "is", "awesome")
$sentence = $words -join " "
Write-Host $sentence  # Output: PowerShell is awesome

# Check variable types
$number = 42
$text = "Hello"
$array = @(1, 2, 3)

Write-Host "`$number is [int]: $($number -is [int])"        # True
Write-Host "`$text is [string]: $($text -is [string])"      # True
Write-Host "`$array is [array]: $($array -is [array])"      # True
Write-Host "`$number is [string]: $($number -is [string])"  # False

# Type conversion using -as
$stringNumber = "123"
$convertedNumber = $stringNumber -as [int]
Write-Host "Type: $($convertedNumber.GetType().Name)"  # Int32
Write-Host "Value: $convertedNumber"  # 123

# Safe conversion (returns $null if fails)
$invalidNumber = "abc"
$result = $invalidNumber -as [int]
if ($null -eq $result) {
    Write-Host "Conversion failed"
} else {
    Write-Host "Converted: $result"
}

# Check for specific .NET types
$date = Get-Date
Write-Host "Is DateTime: $($date -is [DateTime])"  # True

# Check inheritance
$process = Get-Process | Select-Object -First 1
Write-Host "Is Object: $($process -is [Object])"  # True

# -contains checks if collection contains an item
$fruits = @("apple", "banana", "orange", "grape")

if ($fruits -contains "banana") {
    Write-Host "We have bananas!"
}

if ($fruits -notcontains "mango") {
    Write-Host "No mangos available"
}

# -in checks if item is in collection (reverse of -contains)
$searchFruit = "apple"
if ($searchFruit -in $fruits) {
    Write-Host "$searchFruit is in the list"
}

# Case-sensitive versions
$names = @("John", "jane", "Bob")
Write-Host "Contains 'jane': $($names -contains 'jane')"    # True
Write-Host "Contains 'Jane': $($names -ccontains 'Jane')"   # False (case-sensitive)

# Practical example: Check if service is in critical list
$criticalServices = @("wuauserv", "BITS", "EventLog")
$serviceName = "BITS"

if ($serviceName -in $criticalServices) {
    Write-Host "$serviceName is a critical service"
}

# Without parentheses - follows precedence rules
$result1 = 2 + 3 * 4
Write-Host "2 + 3 * 4 = $result1"  # Output: 14 (not 20)

# With parentheses - changes evaluation order
$result2 = (2 + 3) * 4
Write-Host "(2 + 3) * 4 = $result2"  # Output: 20

# Complex expression
$result3 = 10 + 5 * 2 - 3
Write-Host "10 + 5 * 2 - 3 = $result3"  # Output: 17

# Logical operators precedence
$a = $true
$b = $false
$c = $true

# AND has higher precedence than OR
$result4 = $a -or $b -and $c
Write-Host "`$true -or `$false -and `$true = $result4"  # True

# Use parentheses for clarity
$result5 = ($a -or $b) -and $c
Write-Host "(`$true -or `$false) -and `$true = $result5"  # True

# Best practice: Use parentheses for complex expressions
$age = 25
$hasLicense = $true
$hasInsurance = $true

# Clear and explicit
if (($age -ge 18) -and ($hasLicense -and $hasInsurance)) {
    Write-Host "Eligible to drive"
}

# Create a range of numbers
$numbers = 1..10
Write-Host "Numbers: $($numbers -join ', ')"  # 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

# Reverse range
$countdown = 10..1
Write-Host "Countdown: $($countdown -join ', ')"

# Use range in loop
foreach ($i in 1..5) {
    Write-Host "Iteration $i"
}

# Create array of years
$years = 2020..2026
Write-Host "Years: $($years -join ', ')"

# Use range for array slicing
$letters = 'a', 'b', 'c', 'd', 'e', 'f'
$subset = $letters[1..3]
Write-Host "Subset: $($subset -join ', ')"  # b, c, d

# Execute command stored in variable
$command = "Get-Process"
& $command | Select-Object -First 5

# Execute script from variable
$scriptPath = "C:\Scripts\MyScript.ps1"
if (Test-Path $scriptPath) {
    & $scriptPath
}

# Execute command with spaces in path
$program = "C:\Program Files\MyApp\app.exe"
& $program

# Execute with arguments
$exe = "notepad.exe"
$file = "C:\Temp\notes.txt"
& $exe $file

# Create array using comma operator
$colors = "red", "green", "blue"
Write-Host "Colors: $($colors -join ', ')"

# Single element array
$singleItem = , "only one"
Write-Host "Count: $($singleItem.Count)"  # 1

# Nested arrays
$matrix = @(
    (1, 2, 3),
    (4, 5, 6),
    (7, 8, 9)
)
Write-Host "Matrix [1][1]: $($matrix[1][1])"  # 5

$age = 25

if ($age -ge 18) {
    Write-Host "You are an adult."
}

# Output: You are an adult.

$temperature = 15

if ($temperature -gt 20) {
    Write-Host "It's warm outside."
} else {
    Write-Host "It's cold outside."
}

# Output: It's cold outside.

$score = 85

if ($score -ge 90) {
    $grade = "A"
} elseif ($score -ge 80) {
    $grade = "B"
} elseif ($score -ge 70) {
    $grade = "C"
} elseif ($score -ge 60) {
    $grade = "D"
} else {
    $grade = "F"
}

Write-Host "Your grade is: $grade"
# Output: Your grade is: B

$username = "admin"
$password = "secret123"

if ($username -eq "admin") {
    if ($password -eq "secret123") {
        Write-Host "Login successful!"
    } else {
        Write-Host "Invalid password."
    }
} else {
    Write-Host "Invalid username."
}

# Output: Login successful!

# Using -and
$age = 25
$hasLicense = $true

if ($age -ge 18 -and $hasLicense) {
    Write-Host "You can drive."
}

# Using -or
$isWeekend = $false
$isHoliday = $true

if ($isWeekend -or $isHoliday) {
    Write-Host "No work today!"
}

# Using -not
$isRaining = $false

if (-not $isRaining) {
    Write-Host "You don't need an umbrella."
}

$day = "Monday"

switch ($day) {
    "Monday"    { Write-Host "Start of the work week" }
    "Tuesday"   { Write-Host "Second day" }
    "Wednesday" { Write-Host "Midweek" }
    "Thursday"  { Write-Host "Almost Friday" }
    "Friday"    { Write-Host "TGIF!" }
    "Saturday"  { Write-Host "Weekend!" }
    "Sunday"    { Write-Host "Rest day" }
    default     { Write-Host "Invalid day" }
}

# Output: Start of the work week

$number = 2

switch ($number) {
    {$_ -lt 0}  { Write-Host "Negative number" }
    {$_ -eq 0}  { Write-Host "Zero" }
    {$_ -gt 0}  { Write-Host "Positive number" }
    {$_ % 2 -eq 0} { Write-Host "Even number" }
    {$_ % 2 -ne 0} { Write-Host "Odd number" }
}

# Output:
# Positive number
# Even number

$filename = "document.txt"

switch -Wildcard ($filename) {
    "*.txt"  { Write-Host "Text file" }
    "*.pdf"  { Write-Host "PDF file" }
    "*.docx" { Write-Host "Word document" }
    "*.jpg"  { Write-Host "Image file" }
    default  { Write-Host "Unknown file type" }
}

# Output: Text file

$email = "[email protected]"

switch -Regex ($email) {
    "^[a-z]+"           { Write-Host "Starts with lowercase letters" }
    "@"                 { Write-Host "Contains @ symbol" }
    "\.com$"            { Write-Host "Ends with .com" }
    "^\w+@\w+\.\w+$"    { Write-Host "Valid email format" }
}

# Output:
# Starts with lowercase letters
# Contains @ symbol
# Ends with .com
# Valid email format

$numbers = 1, 2, 3, 4, 5

switch ($numbers) {
    {$_ % 2 -eq 0} { Write-Host "$_ is even" }
    {$_ % 2 -ne 0} { Write-Host "$_ is odd" }
}

# Output:
# 1 is odd
# 2 is even
# 3 is odd
# 4 is even
# 5 is odd

# Count from 1 to 5
for ($i = 1; $i -le 5; $i++) {
    Write-Host "Count: $i"
}

# Output:
# Count: 1
# Count: 2
# Count: 3
# Count: 4
# Count: 5

# Count by 2s
for ($i = 0; $i -le 10; $i += 2) {
    Write-Host $i
}

# Output: 0 2 4 6 8 10

# Count backwards
for ($i = 10; $i -ge 1; $i--) {
    Write-Host $i
}

# Output: 10 9 8 7 6 5 4 3 2 1

# Create a multiplication table
for ($i = 1; $i -le 5; $i++) {
    for ($j = 1; $j -le 5; $j++) {
        $result = $i * $j
        Write-Host "$i x $j = $result"
    }
    Write-Host "---"
}

$fruits = "Apple", "Banana", "Orange", "Grape"

foreach ($fruit in $fruits) {
    Write-Host "I like $fruit"
}

# Output:
# I like Apple
# I like Banana
# I like Orange
# I like Grape

$ages = @{
    "John" = 25
    "Jane" = 30
    "Bob"  = 35
}

foreach ($person in $ages.Keys) {
    Write-Host "$person is $($ages[$person]) years old"
}

# Output:
# John is 25 years old
# Jane is 30 years old
# Bob is 35 years old

# Using ForEach-Object (alias: foreach, %)
1..5 | ForEach-Object {
    Write-Host "Number: $_"
}

# Shorter syntax
1..5 | % { Write-Host "Number: $_" }

# Processing files
Get-ChildItem -Path C:\Temp -Filter *.txt | ForEach-Object {
    Write-Host "File: $($_.Name), Size: $($_.Length) bytes"
}

$count = 1

while ($count -le 5) {
    Write-Host "Count: $count"
    $count++
}

# Output:
# Count: 1
# Count: 2
# Count: 3
# Count: 4
# Count: 5

$password = ""

while ($password -ne "secret") {
    $password = Read-Host "Enter password"
    if ($password -ne "secret") {
        Write-Host "Incorrect password. Try again."
    }
}

Write-Host "Access granted!"

$count = 1

do {
    Write-Host "Count: $count"
    $count++
} while ($count -le 5)

# Output:
# Count: 1
# Count: 2
# Count: 3
# Count: 4
# Count: 5

$count = 1

do {
    Write-Host "Count: $count"
    $count++
} until ($count -gt 5)

# Output:
# Count: 1
# Count: 2
# Count: 3
# Count: 4
# Count: 5

# While loop - may not execute at all
$count = 10
while ($count -lt 5) {
    Write-Host "This won't print"
}

# Do-While loop - executes at least once
$count = 10
do {
    Write-Host "This prints once: $count"
} while ($count -lt 5)

# Output: This prints once: 10

# Exit loop when condition is met
for ($i = 1; $i -le 10; $i++) {
    if ($i -eq 5) {
        Write-Host "Breaking at $i"
        break
    }
    Write-Host $i
}

# Output:
# 1
# 2
# 3
# 4
# Breaking at 5

# Skip even numbers
for ($i = 1; $i -le 10; $i++) {
    if ($i % 2 -eq 0) {
        continue
    }
    Write-Host $i
}

# Output: 1 3 5 7 9

:outer for ($i = 1; $i -le 3; $i++) {
    for ($j = 1; $j -le 3; $j++) {
        if ($i -eq 2 -and $j -eq 2) {
            Write-Host "Breaking outer loop at i=$i, j=$j"
            break outer
        }
        Write-Host "i=$i, j=$j"
    }
}

# Output:
# i=1, j=1
# i=1, j=2
# i=1, j=3
# i=2, j=1
# Breaking outer loop at i=2, j=2

$files = Get-ChildItem -Path C:\Temp

foreach ($file in $files) {
    switch -Wildcard ($file.Extension) {
        ".txt" {
            Write-Host "Text file: $($file.Name)"
            # Process text file
        }
        ".log" {
            Write-Host "Log file: $($file.Name)"
            # Archive log file
        }
        ".tmp" {
            Write-Host "Temp file: $($file.Name) - Deleting"
            # Remove-Item $file.FullName
        }
        default {
            Write-Host "Other file: $($file.Name)"
        }
    }
}

$services = "Spooler", "wuauserv", "BITS"

foreach ($serviceName in $services) {
    $service = Get-Service -Name $serviceName
    
    if ($service.Status -eq "Running") {
        Write-Host "$serviceName is running - OK" -ForegroundColor Green
    } else {
        Write-Host "$serviceName is stopped - Attempting restart" -ForegroundColor Yellow
        
        try {
            Start-Service -Name $serviceName
            Write-Host "$serviceName restarted successfully" -ForegroundColor Green
        } catch {
            Write-Host "Failed to restart $serviceName" -ForegroundColor Red
        }
    }
}

$maxAttempts = 3
$attempts = 0
$validInput = $false

do {
    $age = Read-Host "Enter your age (1-120)"
    $attempts++
    
    if ($age -match '^\d+$') {
        $ageNum = [int]$age
        if ($ageNum -ge 1 -and $ageNum -le 120) {
            Write-Host "Valid age: $ageNum" -ForegroundColor Green
            $validInput = $true
        } else {
            Write-Host "Age must be between 1 and 120" -ForegroundColor Red
        }
    } else {
        Write-Host "Please enter a valid number" -ForegroundColor Red
    }
    
    if (-not $validInput -and $attempts -lt $maxAttempts) {
        Write-Host "Attempts remaining: $($maxAttempts - $attempts)"
    }
    
} while (-not $validInput -and $attempts -lt $maxAttempts)

if (-not $validInput) {
    Write-Host "Maximum attempts reached. Exiting." -ForegroundColor Red
}

function FunctionName {
    # Function body
    # Code to execute
}

# Define a simple function
function Say-Hello {
    Write-Host "Hello, PowerShell!"
}

# Call the function
Say-Hello

# Output: Hello, PowerShell!

# Function that performs a task
function Get-SystemInfo {
    $os = Get-CimInstance Win32_OperatingSystem
    $computer = Get-CimInstance Win32_ComputerSystem
    
    Write-Host "Computer Name: $($computer.Name)"
    Write-Host "OS: $($os.Caption)"
    Write-Host "Version: $($os.Version)"
    Write-Host "Total Memory: $([math]::Round($computer.TotalPhysicalMemory/1GB, 2)) GB"
}

# Call the function
Get-SystemInfo

# Function with one parameter
function Say-HelloTo {
    param($Name)
    Write-Host "Hello, $Name!"
}

# Call with argument
Say-HelloTo -Name "Alice"
# Output: Hello, Alice!

# Positional argument (no parameter name)
Say-HelloTo "Bob"
# Output: Hello, Bob!

# Function with multiple parameters
function Get-FullName {
    param(
        $FirstName,
        $LastName
    )
    return "$FirstName $LastName"
}

# Call the function
$name = Get-FullName -FirstName "John" -LastName "Doe"
Write-Host "Full Name: $name"
# Output: Full Name: John Doe

# Function with default parameter values
function Greet-User {
    param(
        $Name = "Guest",
        $Greeting = "Hello"
    )
    Write-Host "$Greeting, $Name!"
}

# Call with no arguments (uses defaults)
Greet-User
# Output: Hello, Guest!

# Call with one argument
Greet-User -Name "Alice"
# Output: Hello, Alice!

# Call with both arguments
Greet-User -Name "Bob" -Greeting "Hi"
# Output: Hi, Bob!

# Function with explicit return
function Add-Numbers {
    param($a, $b)
    return $a + $b
}

$result = Add-Numbers -a 5 -b 3
Write-Host "Result: $result"
# Output: Result: 8

# Function with implicit return
function Multiply-Numbers {
    param($a, $b)
    $a * $b  # This value is automatically returned
}

$result = Multiply-Numbers -a 4 -b 7
Write-Host "Result: $result"
# Output: Result: 28

# Function returning multiple values
function Get-Statistics {
    param([int[]]$Numbers)
    
    $sum = ($Numbers | Measure-Object -Sum).Sum
    $average = ($Numbers | Measure-Object -Average).Average
    $max = ($Numbers | Measure-Object -Maximum).Maximum
    $min = ($Numbers | Measure-Object -Minimum).Minimum
    
    # Return as hashtable
    return @{
        Sum = $sum
        Average = $average
        Maximum = $max
        Minimum = $min
    }
}

$stats = Get-Statistics -Numbers @(10, 20, 30, 40, 50)
Write-Host "Sum: $($stats.Sum)"
Write-Host "Average: $($stats.Average)"
Write-Host "Max: $($stats.Maximum)"
Write-Host "Min: $($stats.Minimum)"

# Function with mandatory parameters
function New-User {
    param(
        [Parameter(Mandatory=$true)]
        [string]$Username,
        
        [Parameter(Mandatory=$true)]
        [string]$Email
    )
    
    Write-Host "Creating user: $Username"
    Write-Host "Email: $Email"
}

# This will prompt for missing parameters
New-User -Username "jdoe"

# Function with parameter validation
function Set-ServerPort {
    param(
        [Parameter(Mandatory=$true)]
        [ValidateRange(1, 65535)]
        [int]$Port,
        
        [Parameter(Mandatory=$true)]
        [ValidateSet("HTTP", "HTTPS", "FTP", "SSH")]
        [string]$Protocol,
        
        [Parameter(Mandatory=$true)]
        [ValidateLength(3, 50)]
        [string]$ServerName
    )
    
    Write-Host "Configuring $ServerName"
    Write-Host "Protocol: $Protocol on port $Port"
}

# Valid call
Set-ServerPort -Port 443 -Protocol "HTTPS" -ServerName "WebServer01"

# Invalid calls will produce errors:
# Set-ServerPort -Port 99999 -Protocol "HTTPS" -ServerName "Web"  # Port out of range
# Set-ServerPort -Port 443 -Protocol "SMTP" -ServerName "Web"     # Invalid protocol

# Function with various validation attributes
function New-Employee {
    param(
        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [string]$Name,
        
        [Parameter(Mandatory=$true)]
        [ValidatePattern("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")]
        [string]$Email,
        
        [Parameter(Mandatory=$true)]
        [ValidateRange(18, 65)]
        [int]$Age,
        
        [ValidateSet("IT", "HR", "Finance", "Sales", "Marketing")]
        [string]$Department = "IT"
    )
    
    Write-Host "Employee: $Name"
    Write-Host "Email: $Email"
    Write-Host "Age: $Age"
    Write-Host "Department: $Department"
}

# Valid call
New-Employee -Name "Alice Smith" -Email "[email protected]" -Age 30 -Department "HR"

# Function with parameter sets
function Get-UserInfo {
    [CmdletBinding(DefaultParameterSetName='ByUsername')]
    param(
        [Parameter(ParameterSetName='ByUsername', Mandatory=$true)]
        [string]$Username,
        
        [Parameter(ParameterSetName='ByID', Mandatory=$true)]
        [int]$UserID,
        
        [Parameter(ParameterSetName='ByEmail', Mandatory=$true)]
        [string]$Email
    )
    
    switch ($PSCmdlet.ParameterSetName) {
        'ByUsername' { Write-Host "Looking up user by username: $Username" }
        'ByID'       { Write-Host "Looking up user by ID: $UserID" }
        'ByEmail'    { Write-Host "Looking up user by email: $Email" }
    }
}

# Use different parameter sets
Get-UserInfo -Username "jdoe"
Get-UserInfo -UserID 12345
Get-UserInfo -Email "[email protected]"

# Script-level variable
$scriptVar = "I'm in script scope"

function Test-Scope {
    # Local variable (only exists in function)
    $localVar = "I'm local to the function"
    
    # Access script variable
    Write-Host "Script variable: $scriptVar"
    Write-Host "Local variable: $localVar"
    
    # Modify script variable using scope modifier
    $script:scriptVar = "Modified from function"
}

Test-Scope
Write-Host "Script variable after function: $scriptVar"
# Write-Host $localVar  # This would error - localVar doesn't exist here

# Demonstrating scope modifiers
$global:globalVar = "Global"
$script:scriptVar = "Script"

function Outer-Function {
    $outerVar = "Outer"
    
    function Inner-Function {
        $innerVar = "Inner"
        
        Write-Host "Inner can see: $innerVar"
        Write-Host "Inner can see outer: $outerVar"
        Write-Host "Inner can see script: $script:scriptVar"
        Write-Host "Inner can see global: $global:globalVar"
        
        # Modify outer scope
        $script:scriptVar = "Modified by Inner"
    }
    
    Inner-Function
    Write-Host "Outer after Inner: $script:scriptVar"
}

Outer-Function

# Function that accepts pipeline input
function Convert-ToUpperCase {
    param(
        [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
        [string]$Text
    )
    
    process {
        $Text.ToUpper()
    }
}

# Use with pipeline
"hello", "world", "powershell" | Convert-ToUpperCase
# Output: HELLO, WORLD, POWERSHELL

# Direct call
Convert-ToUpperCase -Text "test"
# Output: TEST

# Function with begin, process, end blocks
function Get-Sum {
    param(
        [Parameter(ValueFromPipeline=$true)]
        [int]$Number
    )
    
    begin {
        Write-Host "Starting sum calculation..."
        $total = 0
    }
    
    process {
        $total += $Number
        Write-Host "Adding $Number, running total: $total"
    }
    
    end {
        Write-Host "Final sum: $total"
        return $total
    }
}

# Use with pipeline
$result = 1, 2, 3, 4, 5 | Get-Sum
Write-Host "Result: $result"

function Get-DiskInfo {
    <#
    .SYNOPSIS
        Gets disk information for specified computers.
    
    .DESCRIPTION
        The Get-DiskInfo function retrieves disk space information including
        total size, free space, and usage percentage for all drives on one
        or more computers.
    
    .PARAMETER ComputerName
        The name of the computer(s) to query. Defaults to local computer.
    
    .PARAMETER DriveType
        Filter by drive type (3 = Local Disk, 5 = CD-ROM). Default is 3.
    
    .EXAMPLE
        Get-DiskInfo
        Gets disk info for the local computer.
    
    .EXAMPLE
        Get-DiskInfo -ComputerName "Server01", "Server02"
        Gets disk info for multiple computers.
    
    .NOTES
        Author: Your Name
        Version: 1.0
    #>
    
    param(
        [string[]]$ComputerName = $env:COMPUTERNAME,
        [int]$DriveType = 3
    )
    
    foreach ($computer in $ComputerName) {
        Get-CimInstance -ClassName Win32_LogicalDisk -ComputerName $computer |
            Where-Object { $_.DriveType -eq $DriveType } |
            Select-Object DeviceID, 
                          @{Name="SizeGB";Expression={[math]::Round($_.Size/1GB,2)}},
                          @{Name="FreeGB";Expression={[math]::Round($_.FreeSpace/1GB,2)}},
                          @{Name="UsedPercent";Expression={[math]::Round(($_.Size-$_.FreeSpace)/$_.Size*100,2)}}
    }
}

# View help
Get-Help Get-DiskInfo -Full

# MyScript.ps1
# Script description and metadata

param(
    [string]$Name = "World"
)

# Script body
Write-Host "Hello, $Name!"
Write-Host "This script is running from: $PSScriptRoot"

# Functions can be defined in scripts
function Get-ScriptInfo {
    Write-Host "Script: $($MyInvocation.MyCommand.Name)"
    Write-Host "Path: $PSCommandPath"
}

Get-ScriptInfo

# Method 1: Full path
C:\Scripts\MyScript.ps1

# Method 2: Relative path
.\MyScript.ps1

# Method 3: With parameters
.\MyScript.ps1 -Name "Alice"

# Method 4: Using Invoke-Expression
Invoke-Expression ".\MyScript.ps1"

# Method 5: Dot sourcing (loads functions into current scope)
. .\MyScript.ps1

# Check current execution policy
Get-ExecutionPolicy

# Set execution policy (requires admin)
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

# Execution policy levels:
# - Restricted: No scripts allowed
# - AllSigned: Only signed scripts
# - RemoteSigned: Local scripts OK, remote must be signed
# - Unrestricted: All scripts allowed (with warning)
# - Bypass: Nothing blocked, no warnings

# Temporarily bypass for one script
powershell.exe -ExecutionPolicy Bypass -File .\MyScript.ps1

function New-LocalUserAccount {
    <#
    .SYNOPSIS
        Creates a new local user account with specified properties.
    
    .DESCRIPTION
        Creates a local user account with validation and error handling.
        Supports password generation and group membership.
    
    .EXAMPLE
        New-LocalUserAccount -Username "jdoe" -FullName "John Doe" -Description "IT Staff"
    #>
    
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [ValidateLength(3, 20)]
        [string]$Username,
        
        [Parameter(Mandatory=$true)]
        [string]$FullName,
        
        [string]$Description = "",
        
        [SecureString]$Password,
        
        [switch]$GeneratePassword
    )
    
    begin {
        Write-Verbose "Starting user creation process..."
    }
    
    process {
        try {
            # Generate password if requested
            if ($GeneratePassword) {
                $Password = ConvertTo-SecureString "P@ssw0rd$(Get-Random -Maximum 9999)" -AsPlainText -Force
                Write-Host "Generated password for $Username"
            }
            
            # Validate password exists
            if (-not $Password) {
                throw "Password is required. Use -Password or -GeneratePassword"
            }
            
            # Create user
            $user = New-LocalUser -Name $Username `
                                  -Password $Password `
                                  -FullName $FullName `
                                  -Description $Description `
                                  -ErrorAction Stop
            
            Write-Host "Successfully created user: $Username" -ForegroundColor Green
            return $user
            
        } catch {
            Write-Error "Failed to create user $Username : $_"
            return $null
        }
    }
    
    end {
        Write-Verbose "User creation process completed."
    }
}

# Usage
New-LocalUserAccount -Username "testuser" -FullName "Test User" -GeneratePassword -Verbose

function Analyze-LogFile {
    <#
    .SYNOPSIS
        Analyzes log files for errors, warnings, and patterns.
    
    .DESCRIPTION
        Reads log files and provides statistics on errors, warnings,
        and custom patterns. Supports multiple file formats.
    #>
    
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
        [ValidateScript({Test-Path $_})]
        [string]$LogPath,
        
        [string[]]$ErrorPatterns = @("ERROR", "FAIL", "EXCEPTION"),
        [string[]]$WarningPatterns = @("WARN", "WARNING"),
        
        [switch]$ShowDetails
    )
    
    process {
        Write-Host "Analyzing log file: $LogPath" -ForegroundColor Cyan
        
        # Read log file
        $logContent = Get-Content -Path $LogPath
        $totalLines = $logContent.Count
        
        # Initialize counters
        $errorCount = 0
        $warningCount = 0
        $errorLines = @()
        $warningLines = @()
        
        # Analyze each line
        foreach ($line in $logContent) {
            # Check for errors
            foreach ($pattern in $ErrorPatterns) {
                if ($line -match $pattern) {
                    $errorCount++
                    if ($ShowDetails) {
                        $errorLines += $line
                    }
                    break
                }
            }
            
            # Check for warnings
            foreach ($pattern in $WarningPatterns) {
                if ($line -match $pattern) {
                    $warningCount++
                    if ($ShowDetails) {
                        $warningLines += $line
                    }
                    break
                }
            }
        }
        
        # Create result object
        $result = [PSCustomObject]@{
            LogFile = $LogPath
            TotalLines = $totalLines
            ErrorCount = $errorCount
            WarningCount = $warningCount
            ErrorPercentage = [math]::Round(($errorCount / $totalLines) * 100, 2)
            WarningPercentage = [math]::Round(($warningCount / $totalLines) * 100, 2)
            AnalysisDate = Get-Date
        }
        
        # Display results
        Write-Host "`nAnalysis Results:" -ForegroundColor Yellow
        Write-Host "Total Lines: $totalLines"
        Write-Host "Errors: $errorCount ($($result.ErrorPercentage)%)" -ForegroundColor Red
        Write-Host "Warnings: $warningCount ($($result.WarningPercentage)%)" -ForegroundColor Yellow
        
        # Show details if requested
        if ($ShowDetails) {
            if ($errorLines.Count -gt 0) {
                Write-Host "`nError Lines:" -ForegroundColor Red
                $errorLines | ForEach-Object { Write-Host "  $_" }
            }
            if ($warningLines.Count -gt 0) {
                Write-Host "`nWarning Lines:" -ForegroundColor Yellow
                $warningLines | ForEach-Object { Write-Host "  $_" }
            }
        }
        
        return $result
    }
}

# Usage
# Analyze-LogFile -LogPath "C:\Logspp.log" -ShowDetails

function Start-FolderBackup {
    <#
    .SYNOPSIS
        Creates a compressed backup of specified folders.
    
    .DESCRIPTION
        Backs up folders to a specified location with timestamp and
        optional retention policy.
    #>
    
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [ValidateScript({Test-Path $_})]
        [string]$SourcePath,
        
        [Parameter(Mandatory=$true)]
        [string]$BackupPath,
        
        [int]$RetentionDays = 30,
        
        [switch]$Compress
    )
    
    begin {
        Write-Host "Starting backup process..." -ForegroundColor Cyan
        
        # Create backup directory if it doesn't exist
        if (-not (Test-Path $BackupPath)) {
            New-Item -Path $BackupPath -ItemType Directory | Out-Null
            Write-Host "Created backup directory: $BackupPath"
        }
    }
    
    process {
        try {
            # Generate backup name with timestamp
            $timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
            $sourceName = Split-Path $SourcePath -Leaf
            $backupName = "${sourceName}_${timestamp}"
            
            if ($Compress) {
                # Create compressed backup
                $zipPath = Join-Path $BackupPath "$backupName.zip"
                Write-Host "Creating compressed backup: $zipPath"
                
                Compress-Archive -Path $SourcePath -DestinationPath $zipPath -CompressionLevel Optimal
                
                $backupSize = (Get-Item $zipPath).Length / 1MB
                Write-Host "Backup created successfully! Size: $([math]::Round($backupSize, 2)) MB" -ForegroundColor Green
                
            } else {
                # Create folder backup
                $destPath = Join-Path $BackupPath $backupName
                Write-Host "Creating folder backup: $destPath"
                
                Copy-Item -Path $SourcePath -Destination $destPath -Recurse -Force
                
                $backupSize = (Get-ChildItem $destPath -Recurse | Measure-Object -Property Length -Sum).Sum / 1MB
                Write-Host "Backup created successfully! Size: $([math]::Round($backupSize, 2)) MB" -ForegroundColor Green
            }
            
            # Clean old backups
            Write-Host "Cleaning backups older than $RetentionDays days..."
            $cutoffDate = (Get-Date).AddDays(-$RetentionDays)
            
            Get-ChildItem -Path $BackupPath | 
                Where-Object { $_.LastWriteTime -lt $cutoffDate } |
                ForEach-Object {
                    Write-Host "Removing old backup: $($_.Name)" -ForegroundColor Yellow
                    Remove-Item $_.FullName -Recurse -Force
                }
            
            Write-Host "Backup process completed successfully!" -ForegroundColor Green
            
        } catch {
            Write-Error "Backup failed: $_"
        }
    }
}

# Usage
# Start-FolderBackup -SourcePath "C:\Important" -BackupPath "D:\Backups" -Compress -RetentionDays 30

# This will stop execution
Get-Item "C:\NonExistent.txt" -ErrorAction Stop

# This will show error but continue
Get-Item "C:\NonExistent.txt"
Write-Host "Script continues..."

try {
    # Code that might fail
    $file = Get-Item "C:\NonExistent.txt" -ErrorAction Stop
    Write-Host "File found: $($file.FullName)"
}
catch {
    # Handle the error
    Write-Host "Error occurred: $_" -ForegroundColor Red
}

# Output: Error occurred: Cannot find path 'C:\NonExistent.txt'...

$file = $null
try {
    $file = [System.IO.File]::Open("C:\test.txt", 'Open', 'Read')
    $content = [System.IO.StreamReader]::new($file)
    Write-Host $content.ReadToEnd()
}
catch {
    Write-Host "Error reading file: $_" -ForegroundColor Red
}
finally {
    # This ALWAYS executes, even if there's an error
    if ($file) {
        $file.Close()
        Write-Host "File closed"
    }
}

try {
    $file = Get-Item "C:\test.txt" -ErrorAction Stop
    $content = Get-Content $file.FullName -ErrorAction Stop
}
catch [System.IO.FileNotFoundException] {
    Write-Host "File not found!" -ForegroundColor Red
}
catch [System.UnauthorizedAccessException] {
    Write-Host "Access denied!" -ForegroundColor Red
}
catch {
    Write-Host "An unexpected error occurred: $_" -ForegroundColor Red
}

try {
    Get-Item "C:\NonExistent.txt" -ErrorAction Stop
}
catch {
    Write-Host "Error Message: $($_.Exception.Message)"
    Write-Host "Error Type: $($_.Exception.GetType().FullName)"
    Write-Host "Line Number: $($_.InvocationInfo.ScriptLineNumber)"
    Write-Host "Command: $($_.InvocationInfo.MyCommand)"
}

# Check last command status
Get-Process "NonExistent" -ErrorAction SilentlyContinue
if (-not $?) {
    Write-Host "Last command failed"
}

# View all errors
Write-Host "Total errors in session: $($Error.Count)"
$Error[0]  # Most recent error

# Stop - Convert to terminating error
try {
    Get-Item "C:\NonExistent.txt" -ErrorAction Stop
}
catch {
    Write-Host "Caught error!"
}

# SilentlyContinue - Suppress error message
$file = Get-Item "C:\NonExistent.txt" -ErrorAction SilentlyContinue
if ($null -eq $file) {
    Write-Host "File doesn't exist (no error shown)"
}

# Ignore - Don't even add to $Error array
$errorCount = $Error.Count
Get-Item "C:\NonExistent.txt" -ErrorAction Ignore
Write-Host "Error count unchanged: $($Error.Count -eq $errorCount)"

function Divide-Numbers {
    param([int]$a, [int]$b)
    
    if ($b -eq 0) {
        throw "Cannot divide by zero!"
    }
    
    return $a / $b
}

try {
    $result = Divide-Numbers -a 10 -b 0
}
catch {
    Write-Host "Error: $_" -ForegroundColor Red
}

# Throw with custom exception type
if ($age -lt 18) {
    throw [System.ArgumentException]::new("Age must be 18 or older")
}

function Process-Files {
    param([string[]]$Files)
    
    foreach ($file in $Files) {
        if (-not (Test-Path $file)) {
            Write-Error "File not found: $file"
            continue  # Continue processing other files
        }
        
        Write-Host "Processing: $file"
        # Process file...
    }
}

Process-Files -Files @("C:\file1.txt", "C:\missing.txt", "C:\file3.txt")
# Output shows error for missing.txt but continues with file3.txt

function Get-UserData {
    [CmdletBinding()]
    param([string]$Username)
    
    Write-Verbose "Starting user data retrieval for: $Username"
    Write-Debug "Debug point 1: Before validation"
    
    if ([string]::IsNullOrEmpty($Username)) {
        Write-Error "Username cannot be empty"
        return
    }
    
    Write-Debug "Debug point 2: After validation"
    Write-Verbose "Querying Active Directory..."
    
    # Simulate data retrieval
    $userData = @{
        Username = $Username
        Email = "[email protected]"
    }
    
    Write-Verbose "User data retrieved successfully"
    return $userData
}

# Run with verbose output
Get-UserData -Username "john" -Verbose

# Run with debug output (requires $DebugPreference = "Continue")
$DebugPreference = "Continue"
Get-UserData -Username "john" -Debug
$DebugPreference = "SilentlyContinue"  # Reset

# Set breakpoint on line number
Set-PSBreakpoint -Script "C:\Scripts\MyScript.ps1" -Line 10

# Set breakpoint on variable access
Set-PSBreakpoint -Variable "errorCount" -Mode ReadWrite

# Set breakpoint on command
Set-PSBreakpoint -Command "Get-Process"

# List all breakpoints
Get-PSBreakpoint

# Remove breakpoints
Remove-PSBreakpoint -Id 1
Get-PSBreakpoint | Remove-PSBreakpoint  # Remove all

# Start recording all output
Start-Transcript -Path "C:\Logs\script_log.txt"

# Your script commands here
Write-Host "This will be recorded"
Get-Process | Select-Object -First 5

# Stop recording
Stop-Transcript

# The transcript file contains all input and output

function Process-LogFile {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [string]$Path,
        
        [string]$OutputPath = "C:\Processed"
    )
    
    # Validate input
    if (-not (Test-Path $Path)) {
        Write-Error "Input file not found: $Path"
        return
    }
    
    # Create output directory if needed
    try {
        if (-not (Test-Path $OutputPath)) {
            New-Item -Path $OutputPath -ItemType Directory -ErrorAction Stop | Out-Null
            Write-Verbose "Created output directory: $OutputPath"
        }
    }
    catch {
        Write-Error "Failed to create output directory: $_"
        return
    }
    
    # Process file
    $processedLines = @()
    $errorCount = 0
    
    try {
        $lines = Get-Content $Path -ErrorAction Stop
        
        foreach ($line in $lines) {
            try {
                # Process each line
                $processed = $line.Trim().ToUpper()
                $processedLines += $processed
            }
            catch {
                Write-Warning "Failed to process line: $line"
                $errorCount++
            }
        }
        
        # Save results
        $outputFile = Join-Path $OutputPath "processed_$(Get-Date -Format 'yyyyMMdd_HHmmss').txt"
        $processedLines | Set-Content $outputFile -ErrorAction Stop
        
        Write-Host "Processing complete!" -ForegroundColor Green
        Write-Host "Processed: $($processedLines.Count) lines"
        Write-Host "Errors: $errorCount"
        Write-Host "Output: $outputFile"
    }
    catch {
        Write-Error "Fatal error during processing: $_"
    }
}

# Usage
Process-LogFile -Path "C:\Logs\app.log" -Verbose

function Invoke-WebRequestWithRetry {
    param(
        [string]$Url,
        [int]$MaxRetries = 3,
        [int]$RetryDelaySeconds = 5
    )
    
    $attempt = 0
    
    while ($attempt -lt $MaxRetries) {
        $attempt++
        
        try {
            Write-Host "Attempt $attempt of $MaxRetries..."
            
            $response = Invoke-WebRequest -Uri $Url -ErrorAction Stop
            
            Write-Host "Success!" -ForegroundColor Green
            return $response
        }
        catch [System.Net.WebException] {
            $statusCode = $_.Exception.Response.StatusCode.value__
            
            Write-Warning "Web request failed with status code: $statusCode"
            
            if ($attempt -lt $MaxRetries) {
                Write-Host "Retrying in $RetryDelaySeconds seconds..."
                Start-Sleep -Seconds $RetryDelaySeconds
            }
            else {
                Write-Error "Max retries reached. Giving up."
                throw
            }
        }
        catch {
            Write-Error "Unexpected error: $_"
            throw
        }
    }
}

# Usage
try {
    $result = Invoke-WebRequestWithRetry -Url "https://api.example.com/data"
    Write-Host "Data retrieved: $($result.Content.Length) bytes"
}
catch {
    Write-Host "Failed to retrieve data after all retries"
}

function Write-ErrorLog {
    param(
        [string]$Message,
        [string]$LogPath = "C:\Logs\errors.log",
        [ValidateSet("Info", "Warning", "Error", "Critical")]
        [string]$Level = "Error"
    )
    
    try {
        # Create log directory if needed
        $logDir = Split-Path $LogPath -Parent
        if (-not (Test-Path $logDir)) {
            New-Item -Path $logDir -ItemType Directory -Force | Out-Null
        }
        
        # Format log entry
        $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
        $logEntry = "[$timestamp] [$Level] $Message"
        
        # Write to log file
        Add-Content -Path $LogPath -Value $logEntry -ErrorAction Stop
        
        # Also write to console with color
        $color = switch ($Level) {
            "Info"     { "White" }
            "Warning"  { "Yellow" }
            "Error"    { "Red" }
            "Critical" { "Magenta" }
        }
        
        Write-Host $logEntry -ForegroundColor $color
    }
    catch {
        Write-Warning "Failed to write to log file: $_"
    }
}

# Usage in script
try {
    # Your code here
    Get-Item "C:\NonExistent.txt" -ErrorAction Stop
}
catch {
    Write-ErrorLog -Message "File operation failed: $_" -Level "Error"
    Write-ErrorLog -Message "Stack trace: $($_.ScriptStackTrace)" -Level "Error"
}

# List registry drives
Get-PSDrive -PSProvider Registry

# Output shows:
# HKCU: (HKEY_CURRENT_USER)
# HKLM: (HKEY_LOCAL_MACHINE)

# Change to registry location
Set-Location HKCU:\Software

# List keys (like folders)
Get-ChildItem

# View current location
Get-Location

# Read all properties from a key
Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer"

# Read specific property
Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer" -Name "ShellState"

# Read from HKLM (requires admin for some keys)
Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name "ProductName"

# Get Windows version information
$regPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion"
$version = Get-ItemProperty -Path $regPath

Write-Host "Product Name: $($version.ProductName)"
Write-Host "Current Build: $($version.CurrentBuild)"
Write-Host "Release ID: $($version.ReleaseId)"

# Create a new registry key
New-Item -Path "HKCU:\Software\MyApp" -Force

# Create nested keys
New-Item -Path "HKCU:\Software\MyApp\Settings\Advanced" -Force

# The -Force parameter creates parent keys if they don't exist

# Create a String value
New-ItemProperty -Path "HKCU:\Software\MyApp" -Name "AppPath" -Value "C:\MyApp" -PropertyType String

# Create a DWORD value (32-bit integer)
New-ItemProperty -Path "HKCU:\Software\MyApp" -Name "Version" -Value 1 -PropertyType DWord

# Create a Binary value
$binaryData = [byte[]](0x01, 0x02, 0x03, 0x04)
New-ItemProperty -Path "HKCU:\Software\MyApp" -Name "BinaryData" -Value $binaryData -PropertyType Binary

# Create a Multi-String value
New-ItemProperty -Path "HKCU:\Software\MyApp" -Name "Servers" -Value @("Server1", "Server2") -PropertyType MultiString

# Modify a string value
Set-ItemProperty -Path "HKCU:\Software\MyApp" -Name "AppPath" -Value "D:\MyApp"

# Modify a DWORD value
Set-ItemProperty -Path "HKCU:\Software\MyApp" -Name "Version" -Value 2

# Modify multiple values at once
$properties = @{
    "AppPath" = "E:\MyApp"
    "Version" = 3
}
Set-ItemProperty -Path "HKCU:\Software\MyApp" -Name $properties.Keys -Value $properties.Values

# Rename a registry value
Rename-ItemProperty -Path "HKCU:\Software\MyApp" -Name "AppPath" -NewName "ApplicationPath"

# Delete a specific value
Remove-ItemProperty -Path "HKCU:\Software\MyApp" -Name "Version"

# Delete with confirmation
Remove-ItemProperty -Path "HKCU:\Software\MyApp" -Name "Version" -Confirm

# Delete a registry key (must be empty or use -Recurse)
Remove-Item -Path "HKCU:\Software\MyApp\Settings"

# Delete key and all subkeys/values
Remove-Item -Path "HKCU:\Software\MyApp" -Recurse -Force

# Safe deletion with WhatIf
Remove-Item -Path "HKCU:\Software\MyApp" -Recurse -WhatIf

# Check if registry key exists
if (Test-Path "HKCU:\Software\MyApp") {
    Write-Host "MyApp key exists"
} else {
    Write-Host "MyApp key does not exist"
}

# Check if specific value exists
$path = "HKCU:\Software\MyApp"
$valueName = "Version"
$property = Get-ItemProperty -Path $path -Name $valueName -ErrorAction SilentlyContinue

if ($property) {
    Write-Host "Value exists: $($property.$valueName)"
} else {
    Write-Host "Value does not exist"
}

# Export registry key to .reg file
# Using reg.exe command
reg export "HKCU\Software\MyApp" "C:\Backup\MyApp.reg" /y

# PowerShell method - export to XML
$regPath = "HKCU:\Software\MyApp"
$backupFile = "C:\Backup\MyApp.xml"

if (Test-Path $regPath) {
    Get-ItemProperty -Path $regPath | Export-Clixml -Path $backupFile
    Write-Host "Registry backed up to $backupFile"
}

# Import from .reg file
reg import "C:\Backup\MyApp.reg"

# PowerShell method - restore from XML
$backupFile = "C:\Backup\MyApp.xml"
$regPath = "HKCU:\Software\MyApp"

if (Test-Path $backupFile) {
    $backup = Import-Clixml -Path $backupFile
    
    # Recreate key if needed
    if (-not (Test-Path $regPath)) {
        New-Item -Path $regPath -Force
    }
    
    # Restore each property
    $backup.PSObject.Properties | ForEach-Object {
        if ($_.Name -notin @('PSPath', 'PSParentPath', 'PSChildName', 'PSDrive', 'PSProvider')) {
            Set-ItemProperty -Path $regPath -Name $_.Name -Value $_.Value
        }
    }
    Write-Host "Registry restored from $backupFile"
}

function Test-SoftwareInstalled {
    param(
        [string]$SoftwareName
    )
    
    # Check both 32-bit and 64-bit registry locations
    $paths = @(
        "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
        "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*"
    )
    
    foreach ($path in $paths) {
        $installed = Get-ItemProperty -Path $path -ErrorAction SilentlyContinue | 
                     Where-Object { $_.DisplayName -like "*$SoftwareName*" }
        
        if ($installed) {
            Write-Host "Found: $($installed.DisplayName)"
            Write-Host "Version: $($installed.DisplayVersion)"
            Write-Host "Publisher: $($installed.Publisher)"
            return $true
        }
    }
    
    Write-Host "$SoftwareName not found"
    return $false
}

# Usage
Test-SoftwareInstalled -SoftwareName "Google Chrome"

function Set-AppConfiguration {
    param(
        [string]$AppName,
        [hashtable]$Settings
    )
    
    $regPath = "HKCU:\Software\$AppName"
    
    # Create key if it doesn't exist
    if (-not (Test-Path $regPath)) {
        New-Item -Path $regPath -Force | Out-Null
        Write-Host "Created registry key: $regPath"
    }
    
    # Set each setting
    foreach ($key in $Settings.Keys) {
        $value = $Settings[$key]
        
        # Determine type
        $type = switch ($value.GetType().Name) {
            "Int32" { "DWord" }
            "String" { "String" }
            "String[]" { "MultiString" }
            default { "String" }
        }
        
        # Check if property exists
        $existing = Get-ItemProperty -Path $regPath -Name $key -ErrorAction SilentlyContinue
        
        if ($existing) {
            Set-ItemProperty -Path $regPath -Name $key -Value $value
            Write-Host "Updated: $key = $value"
        } else {
            New-ItemProperty -Path $regPath -Name $key -Value $value -PropertyType $type | Out-Null
            Write-Host "Created: $key = $value"
        }
    }
}

# Usage
$config = @{
    "ServerURL" = "https://api.example.com"
    "Timeout" = 30
    "EnableLogging" = 1
    "AllowedUsers" = @("User1", "User2", "User3")
}

Set-AppConfiguration -AppName "MyApp" -Settings $config

function Get-RegistrySnapshot {
    param(
        [string]$Path
    )
    
    $snapshot = @{}
    
    if (Test-Path $Path) {
        # Get all properties
        $properties = Get-ItemProperty -Path $Path
        
        foreach ($prop in $properties.PSObject.Properties) {
            if ($prop.Name -notin @('PSPath', 'PSParentPath', 'PSChildName', 'PSDrive', 'PSProvider')) {
                $snapshot[$prop.Name] = $prop.Value
            }
        }
        
        # Get all subkeys
        $subkeys = Get-ChildItem -Path $Path -ErrorAction SilentlyContinue
        foreach ($subkey in $subkeys) {
            $snapshot[$subkey.PSChildName] = Get-RegistrySnapshot -Path $subkey.PSPath
        }
    }
    
    return $snapshot
}

function Compare-RegistrySnapshots {
    param(
        [hashtable]$Before,
        [hashtable]$After
    )
    
    $changes = @()
    
    # Check for new or modified values
    foreach ($key in $After.Keys) {
        if (-not $Before.ContainsKey($key)) {
            $changes += "ADDED: $key = $($After[$key])"
        } elseif ($Before[$key] -ne $After[$key]) {
            $changes += "MODIFIED: $key = $($Before[$key]) -> $($After[$key])"
        }
    }
    
    # Check for deleted values
    foreach ($key in $Before.Keys) {
        if (-not $After.ContainsKey($key)) {
            $changes += "DELETED: $key"
        }
    }
    
    return $changes
}

# Usage
$path = "HKCU:\Software\MyApp"
$before = Get-RegistrySnapshot -Path $path

# ... make changes ...

$after = Get-RegistrySnapshot -Path $path
$changes = Compare-RegistrySnapshots -Before $before -After $after

if ($changes.Count -gt 0) {
    Write-Host "Registry changes detected:"
    $changes | ForEach-Object { Write-Host "  $_" }
} else {
    Write-Host "No changes detected"
}

function Set-RegistryValueSafely {
    param(
        [string]$Path,
        [string]$Name,
        $Value,
        [string]$Type = "String"
    )
    
    try {
        # Backup first
        $backupPath = "$env:TEMP\RegBackup_$(Get-Date -Format 'yyyyMMdd_HHmmss').xml"
        if (Test-Path $Path) {
            Get-ItemProperty -Path $Path | Export-Clixml -Path $backupPath
            Write-Host "Backup created: $backupPath"
        }
        
        # Create key if needed
        if (-not (Test-Path $Path)) {
            New-Item -Path $Path -Force | Out-Null
        }
        
        # Check if value exists
        $existing = Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue
        
        if ($existing) {
            # Modify existing
            Set-ItemProperty -Path $Path -Name $Name -Value $Value
            Write-Host "✓ Modified: $Name = $Value"
        } else {
            # Create new
            New-ItemProperty -Path $Path -Name $Name -Value $Value -PropertyType $Type | Out-Null
            Write-Host "✓ Created: $Name = $Value"
        }
        
        return $true
    }
    catch {
        Write-Error "Failed to set registry value: $_"
        Write-Host "Backup available at: $backupPath"
        return $false
    }
}

# Usage
Set-RegistryValueSafely -Path "HKCU:\Software\MyApp" -Name "Setting1" -Value "Value1" -Type "String"

# Get all services
Get-Service

# Get specific service
Get-Service -Name "Spooler"

# Get services by display name pattern
Get-Service -DisplayName "*Windows*"

# Get multiple services
Get-Service -Name "Spooler", "W32Time", "WinRM"

# Get only running services
Get-Service | Where-Object { $_.Status -eq "Running" }

# Get stopped services
Get-Service | Where-Object { $_.Status -eq "Stopped" }

# Count services by status
Get-Service | Group-Object Status | Select-Object Name, Count

# Get services that can be stopped
Get-Service | Where-Object { $_.CanStop -eq $true }

# Get service with all properties
Get-Service -Name "Spooler" | Select-Object *

# Get service startup type using WMI
Get-WmiObject Win32_Service -Filter "Name='Spooler'" | 
    Select-Object Name, DisplayName, State, StartMode, PathName

# Get service dependencies
$service = Get-Service -Name "Spooler"
Write-Host "Services that $($service.Name) depends on:"
$service.ServicesDependedOn

Write-Host "`nServices that depend on $($service.Name):"
$service.DependentServices

# Start a service
Start-Service -Name "Spooler"

# Start service with confirmation
Start-Service -Name "Spooler" -Confirm

# Start service and display status
Start-Service -Name "Spooler" -PassThru

# Start multiple services
Start-Service -Name "Spooler", "W32Time"

# Stop a service
Stop-Service -Name "Spooler"

# Stop service and dependent services
Stop-Service -Name "Spooler" -Force

# Stop with WhatIf (test without executing)
Stop-Service -Name "Spooler" -WhatIf

# Stop service with timeout
Stop-Service -Name "Spooler" -Force -ErrorAction SilentlyContinue
Start-Sleep -Seconds 5
if ((Get-Service -Name "Spooler").Status -eq "Running") {
    Write-Host "Service did not stop within timeout"
}

# Restart a service
Restart-Service -Name "Spooler"

# Restart with force (stops dependent services)
Restart-Service -Name "Spooler" -Force

# Restart and display result
Restart-Service -Name "Spooler" -PassThru | Select-Object Name, Status

# Change service startup type to Automatic
Set-Service -Name "Spooler" -StartupType Automatic

# Change to Manual
Set-Service -Name "Spooler" -StartupType Manual

# Disable service
Set-Service -Name "Spooler" -StartupType Disabled

# Change display name and description
Set-Service -Name "Spooler" -DisplayName "Print Spooler Service" -Description "Manages print jobs"

# Change service status and startup type
Set-Service -Name "Spooler" -Status Running -StartupType Automatic

# Startup types available:
# - Automatic: Starts at boot
# - AutomaticDelayedStart: Starts shortly after boot
# - Manual: Starts on demand
# - Disabled: Cannot be started

# Set to Automatic (Delayed Start)
Set-Service -Name "MyService" -StartupType Automatic
$service = Get-WmiObject Win32_Service -Filter "Name='MyService'"
$service.ChangeStartMode("Automatic Delayed Start")

# Verify startup type
Get-WmiObject Win32_Service -Filter "Name='MyService'" | Select-Object Name, StartMode

function Get-ServiceDependencies {
    param([string]$ServiceName)
    
    $service = Get-Service -Name $ServiceName
    
    Write-Host "=== Service: $($service.DisplayName) ===" -ForegroundColor Cyan
    Write-Host "Status: $($service.Status)"
    Write-Host ""
    
    Write-Host "Services this service depends on:" -ForegroundColor Yellow
    if ($service.ServicesDependedOn.Count -eq 0) {
        Write-Host "  None"
    } else {
        $service.ServicesDependedOn | ForEach-Object {
            Write-Host "  - $($_.DisplayName) ($($_.Name)) - Status: $($_.Status)"
        }
    }
    
    Write-Host ""
    Write-Host "Services that depend on this service:" -ForegroundColor Yellow
    if ($service.DependentServices.Count -eq 0) {
        Write-Host "  None"
    } else {
        $service.DependentServices | ForEach-Object {
            Write-Host "  - $($_.DisplayName) ($($_.Name)) - Status: $($_.Status)"
        }
    }
}

# Usage
Get-ServiceDependencies -ServiceName "Spooler"

# Get all processes
Get-Process

# Get specific process by name
Get-Process -Name "powershell"

# Get process by ID
Get-Process -Id 1234

# Get multiple processes
Get-Process -Name "chrome", "firefox", "edge"

# Get processes with wildcard
Get-Process -Name "power*"

# Get top 10 processes by CPU usage
Get-Process | Sort-Object CPU -Descending | Select-Object -First 10 Name, CPU, Id

# Get top 10 processes by memory usage
Get-Process | Sort-Object WorkingSet -Descending | 
    Select-Object -First 10 Name, @{Name="Memory(MB)";Expression={[math]::Round($_.WorkingSet/1MB,2)}}, Id

# Get processes using more than 100MB
Get-Process | Where-Object { $_.WorkingSet -gt 100MB } | 
    Select-Object Name, @{Name="Memory(MB)";Expression={[math]::Round($_.WorkingSet/1MB,2)}}

# Get processes by company
Get-Process | Where-Object { $_.Company -like "*Microsoft*" } | 
    Select-Object Name, Company, Path

# Get all properties of a process
Get-Process -Name "powershell" | Select-Object *

# Get process with specific properties
Get-Process | Select-Object Name, Id, CPU, 
    @{Name="Memory(MB)";Expression={[math]::Round($_.WorkingSet/1MB,2)}},
    @{Name="Threads";Expression={$_.Threads.Count}},
    StartTime,
    Path

# Get process modules (DLLs loaded)
Get-Process -Name "powershell" | Select-Object -ExpandProperty Modules | 
    Select-Object ModuleName, FileName

# Get process threads
(Get-Process -Name "powershell").Threads | Select-Object Id, ThreadState, StartTime

# Start notepad
Start-Process notepad

# Start process with arguments
Start-Process notepad -ArgumentList "C:	empile.txt"

# Start process and wait for it to finish
Start-Process notepad -Wait

# Start process in new window
Start-Process powershell -ArgumentList "-NoExit", "-Command", "Get-Process"

# Start process as administrator
Start-Process powershell -Verb RunAs

# Start process with working directory
Start-Process notepad -WorkingDirectory "C:	emp"

# Start process and capture the process object
$proc = Start-Process notepad -PassThru
Write-Host "Started process ID: $($proc.Id)"

# Start process and redirect output
Start-Process ping -ArgumentList "google.com" -RedirectStandardOutput "C:	emp\ping_output.txt" -NoNewWindow -Wait

# Read the output
Get-Content "C:	emp\ping_output.txt"

# Start process with input/output redirection
$psi = New-Object System.Diagnostics.ProcessStartInfo
$psi.FileName = "cmd.exe"
$psi.Arguments = "/c dir C:"
$psi.RedirectStandardOutput = $true
$psi.UseShellExecute = $false
$psi.CreateNoWindow = $true

$process = New-Object System.Diagnostics.Process
$process.StartInfo = $psi
$process.Start() | Out-Null
$output = $process.StandardOutput.ReadToEnd()
$process.WaitForExit()

Write-Host $output

# Stop process by name
Stop-Process -Name "notepad"

# Stop process by ID
Stop-Process -Id 1234

# Stop process forcefully
Stop-Process -Name "notepad" -Force

# Stop multiple processes
Stop-Process -Name "notepad", "calc"

# Stop with confirmation
Stop-Process -Name "notepad" -Confirm

# Stop all instances of a process
Get-Process -Name "notepad" | Stop-Process

# Stop with WhatIf (test without executing)
Stop-Process -Name "notepad" -WhatIf

function Stop-ProcessGracefully {
    param(
        [string]$ProcessName,
        [int]$TimeoutSeconds = 10
    )
    
    $processes = Get-Process -Name $ProcessName -ErrorAction SilentlyContinue
    
    if ($processes) {
        foreach ($proc in $processes) {
            Write-Host "Attempting to close $ProcessName (PID: $($proc.Id))..."
            
            # Try to close gracefully first
            $proc.CloseMainWindow() | Out-Null
            
            # Wait for process to exit
            $proc.WaitForExit($TimeoutSeconds * 1000)
            
            # Check if still running
            if (-not $proc.HasExited) {
                Write-Host "Process did not exit gracefully. Forcing termination..."
                Stop-Process -Id $proc.Id -Force
            } else {
                Write-Host "Process closed successfully."
            }
        }
    } else {
        Write-Host "Process $ProcessName not found."
    }
}

# Usage
Stop-ProcessGracefully -ProcessName "notepad" -TimeoutSeconds 5

function Watch-ProcessResources {
    param(
        [string]$ProcessName,
        [int]$IntervalSeconds = 5
    )
    
    Write-Host "Monitoring $ProcessName (Press Ctrl+C to stop)..." -ForegroundColor Cyan
    Write-Host ""
    
    while ($true) {
        $processes = Get-Process -Name $ProcessName -ErrorAction SilentlyContinue
        
        if ($processes) {
            Clear-Host
            Write-Host "=== Process Monitor: $ProcessName ===" -ForegroundColor Cyan
            Write-Host "Time: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')"
            Write-Host ""
            
            $processes | ForEach-Object {
                $memoryMB = [math]::Round($_.WorkingSet / 1MB, 2)
                $cpuPercent = [math]::Round($_.CPU, 2)
                
                Write-Host "PID: $($_.Id)" -ForegroundColor Yellow
                Write-Host "  CPU: $cpuPercent seconds"
                Write-Host "  Memory: $memoryMB MB"
                Write-Host "  Threads: $($_.Threads.Count)"
                Write-Host "  Handles: $($_.HandleCount)"
                Write-Host ""
            }
        } else {
            Write-Host "Process $ProcessName not running." -ForegroundColor Red
        }
        
        Start-Sleep -Seconds $IntervalSeconds
    }
}

# Usage
# Watch-ProcessResources -ProcessName "chrome" -IntervalSeconds 3

function Monitor-CriticalServices {
    param(
        [string[]]$ServiceNames,
        [string]$LogFile = "C:\Logs\ServiceMonitor.log"
    )
    
    # Ensure log directory exists
    $logDir = Split-Path $LogFile -Parent
    if (-not (Test-Path $logDir)) {
        New-Item -ItemType Directory -Path $logDir -Force | Out-Null
    }
    
    foreach ($serviceName in $ServiceNames) {
        try {
            $service = Get-Service -Name $serviceName -ErrorAction Stop
            
            if ($service.Status -ne "Running") {
                $message = "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - WARNING: $serviceName is $($service.Status)"
                Write-Host $message -ForegroundColor Yellow
                Add-Content -Path $LogFile -Value $message
                
                # Attempt to start the service
                Write-Host "Attempting to start $serviceName..."
                Start-Service -Name $serviceName -ErrorAction Stop
                
                # Wait and verify
                Start-Sleep -Seconds 5
                $service = Get-Service -Name $serviceName
                
                if ($service.Status -eq "Running") {
                    $message = "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - SUCCESS: $serviceName started successfully"
                    Write-Host $message -ForegroundColor Green
                    Add-Content -Path $LogFile -Value $message
                } else {
                    $message = "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - ERROR: Failed to start $serviceName"
                    Write-Host $message -ForegroundColor Red
                    Add-Content -Path $LogFile -Value $message
                }
            } else {
                $message = "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - OK: $serviceName is running"
                Write-Host $message -ForegroundColor Green
            }
        }
        catch {
            $message = "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - ERROR: $serviceName - $_"
            Write-Host $message -ForegroundColor Red
            Add-Content -Path $LogFile -Value $message
        }
    }
}

# Usage
$criticalServices = @("Spooler", "W32Time", "WinRM")
Monitor-CriticalServices -ServiceNames $criticalServices

function Monitor-ProcessResources {
    param(
        [int]$MemoryThresholdMB = 500,
        [int]$CPUThresholdPercent = 80,
        [string]$LogFile = "C:\Logs\ProcessMonitor.log"
    )
    
    $processes = Get-Process | Where-Object { $_.WorkingSet -gt 10MB }
    
    foreach ($proc in $processes) {
        $memoryMB = [math]::Round($proc.WorkingSet / 1MB, 2)
        
        # Check memory threshold
        if ($memoryMB -gt $MemoryThresholdMB) {
            $message = "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - HIGH MEMORY: $($proc.Name) (PID: $($proc.Id)) using $memoryMB MB"
            Write-Host $message -ForegroundColor Red
            Add-Content -Path $LogFile -Value $message
        }
        
        # Check CPU (requires multiple samples for accuracy)
        # This is a simplified version
        if ($proc.CPU -gt 60) {
            $message = "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - HIGH CPU: $($proc.Name) (PID: $($proc.Id)) CPU time: $($proc.CPU) seconds"
            Write-Host $message -ForegroundColor Yellow
            Add-Content -Path $LogFile -Value $message
        }
    }
    
    # Summary
    $totalMemoryMB = [math]::Round((Get-Process | Measure-Object WorkingSet -Sum).Sum / 1MB, 2)
    Write-Host "`nTotal Memory Used: $totalMemoryMB MB" -ForegroundColor Cyan
}

# Usage
Monitor-ProcessResources -MemoryThresholdMB 300

function Export-ServiceReport {
    param(
        [string]$OutputPath = "C:\Reports\ServiceReport.html"
    )
    
    # Get all services
    $services = Get-Service | Sort-Object DisplayName
    
    # Create HTML report
    $html = @"



    
    


    
Service Status Report
    
Generated: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')
    
Computer: $env:COMPUTERNAME
    
    

        
Summary
        
Total Services: $($services.Count)
        
Running: $(($services | Where-Object {$_.Status -eq 'Running'}).Count)
        
Stopped: $(($services | Where-Object {$_.Status -eq 'Stopped'}).Count)
    
    
    
"@
    
    foreach ($service in $services) {
        $wmiService = Get-WmiObject Win32_Service -Filter "Name='$($service.Name)'"
        $statusClass = if ($service.Status -eq "Running") { "running" } else { "stopped" }
        
        $html += @"
        
"@
    }
    
    $html += @"
    

        

            
Display Name
            
Name
            
Status
            
Startup Type
        

            
$($service.DisplayName)
            
$($service.Name)
            
$($service.Status)
            
$($wmiService.StartMode)
        


"@
    
    # Ensure directory exists
    $reportDir = Split-Path $OutputPath -Parent
    if (-not (Test-Path $reportDir)) {
        New-Item -ItemType Directory -Path $reportDir -Force | Out-Null
    }
    
    # Save report
    $html | Out-File -FilePath $OutputPath -Encoding UTF8
    Write-Host "Report saved to: $OutputPath" -ForegroundColor Green
    
    # Open in browser
    Start-Process $OutputPath
}

# Usage
Export-ServiceReport

function Stop-UnresponsiveProcess {
    param(
        [string]$ProcessName,
        [int]$TimeoutSeconds = 30
    )
    
    $processes = Get-Process -Name $ProcessName -ErrorAction SilentlyContinue
    
    if (-not $processes) {
        Write-Host "No processes found with name: $ProcessName" -ForegroundColor Yellow
        return
    }
    
    foreach ($proc in $processes) {
        Write-Host "Checking process: $($proc.Name) (PID: $($proc.Id))" -ForegroundColor Cyan
        
        # Check if process is responding
        if ($proc.Responding) {
            Write-Host "  Process is responding. Attempting graceful close..." -ForegroundColor Green
            
            # Try to close main window
            $closed = $proc.CloseMainWindow()
            
            if ($closed) {
                Write-Host "  Close signal sent. Waiting for exit..."
                $exited = $proc.WaitForExit($TimeoutSeconds * 1000)
                
                if ($exited) {
                    Write-Host "  Process exited successfully." -ForegroundColor Green
                } else {
                    Write-Host "  Process did not exit within timeout. Forcing termination..." -ForegroundColor Yellow
                    Stop-Process -Id $proc.Id -Force
                    Write-Host "  Process terminated forcefully." -ForegroundColor Red
                }
            } else {
                Write-Host "  Could not close main window. Forcing termination..." -ForegroundColor Yellow
                Stop-Process -Id $proc.Id -Force
                Write-Host "  Process terminated forcefully." -ForegroundColor Red
            }
        } else {
            Write-Host "  Process is NOT responding. Forcing termination..." -ForegroundColor Red
            Stop-Process -Id $proc.Id -Force
            Write-Host "  Process terminated forcefully." -ForegroundColor Red
        }
    }
}

# Usage
Stop-UnresponsiveProcess -ProcessName "notepad" -TimeoutSeconds 10

# Get automatic services that are stopped
Get-WmiObject Win32_Service | 
    Where-Object { $_.StartMode -eq "Auto" -and $_.State -eq "Stopped" } |
    Select-Object Name, DisplayName, State, StartMode

# Get services running under specific account
Get-WmiObject Win32_Service | 
    Where-Object { $_.StartName -like "*LocalSystem*" } |
    Select-Object Name, DisplayName, StartName

# Get services with specific path
Get-WmiObject Win32_Service | 
    Where-Object { $_.PathName -like "*system32*" } |
    Select-Object Name, DisplayName, PathName

# Get services that can be paused
Get-Service | Where-Object { $_.CanPauseAndContinue } |
    Select-Object Name, DisplayName, Status

# Get processes started in the last hour
$oneHourAgo = (Get-Date).AddHours(-1)
Get-Process | Where-Object { $_.StartTime -gt $oneHourAgo } |
    Select-Object Name, Id, StartTime, Path

# Get processes with no window title (background processes)
Get-Process | Where-Object { $_.MainWindowTitle -eq "" } |
    Select-Object Name, Id, @{Name="Memory(MB)";Expression={[math]::Round($_.WorkingSet/1MB,2)}}

# Get processes by file version
Get-Process | Where-Object { $_.FileVersion -like "10.*" } |
    Select-Object Name, FileVersion, Company, Path

# Get child processes of a parent
$parentPID = (Get-Process -Name "powershell")[0].Id
Get-WmiObject Win32_Process | Where-Object { $_.ParentProcessId -eq $parentPID } |
    Select-Object ProcessId, Name, CommandLine

function Manage-ServiceSafely {
    param(
        [string]$ServiceName,
        [ValidateSet("Start", "Stop", "Restart")]
        [string]$Action
    )
    
    try {
        # Check if service exists
        $service = Get-Service -Name $ServiceName -ErrorAction Stop
        
        Write-Host "Current Status: $($service.Status)" -ForegroundColor Cyan
        
        # Check dependencies if stopping
        if ($Action -eq "Stop") {
            $dependents = $service.DependentServices | Where-Object { $_.Status -eq "Running" }
            if ($dependents) {
                Write-Host "WARNING: The following services depend on $ServiceName and are running:" -ForegroundColor Yellow
                $dependents | ForEach-Object { Write-Host "  - $($_.DisplayName)" }
                
                $confirm = Read-Host "Continue? (Y/N)"
                if ($confirm -ne "Y") {
                    Write-Host "Operation cancelled."
                    return
                }
            }
        }
        
        # Perform action
        switch ($Action) {
            "Start" {
                if ($service.Status -eq "Running") {
                    Write-Host "Service is already running." -ForegroundColor Green
                } else {
                    Start-Service -Name $ServiceName
                    Write-Host "Service started successfully." -ForegroundColor Green
                }
            }
            "Stop" {
                if ($service.Status -eq "Stopped") {
                    Write-Host "Service is already stopped." -ForegroundColor Green
                } else {
                    Stop-Service -Name $ServiceName -Force
                    Write-Host "Service stopped successfully." -ForegroundColor Green
                }
            }
            "Restart" {
                Restart-Service -Name $ServiceName -Force
                Write-Host "Service restarted successfully." -ForegroundColor Green
            }
        }
        
        # Verify final status
        $service = Get-Service -Name $ServiceName
        Write-Host "Final Status: $($service.Status)" -ForegroundColor Cyan
    }
    catch {
        Write-Error "Failed to manage service: $_"
    }
}

# Usage
Manage-ServiceSafely -ServiceName "Spooler" -Action "Restart"

function Show-PerformanceDashboard {
    param([int]$RefreshSeconds = 5)
    
    while ($true) {
        Clear-Host
        
        Write-Host "=== SYSTEM PERFORMANCE DASHBOARD ===" -ForegroundColor Cyan
        Write-Host "Time: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')"
        Write-Host "Computer: $env:COMPUTERNAME"
        Write-Host ""
        
        # CPU and Memory
        $cpu = Get-WmiObject Win32_Processor | Measure-Object -Property LoadPercentage -Average
        $os = Get-WmiObject Win32_OperatingSystem
        $totalMemGB = [math]::Round($os.TotalVisibleMemorySize / 1MB, 2)
        $freeMemGB = [math]::Round($os.FreePhysicalMemory / 1MB, 2)
        $usedMemGB = $totalMemGB - $freeMemGB
        $memPercent = [math]::Round(($usedMemGB / $totalMemGB) * 100, 2)
        
        Write-Host "SYSTEM RESOURCES:" -ForegroundColor Yellow
        Write-Host "  CPU Usage: $($cpu.Average)%"
        Write-Host "  Memory: $usedMemGB GB / $totalMemGB GB ($memPercent%)"
        Write-Host ""
        
        # Top 5 CPU processes
        Write-Host "TOP 5 CPU PROCESSES:" -ForegroundColor Yellow
        Get-Process | Sort-Object CPU -Descending | Select-Object -First 5 | ForEach-Object {
            Write-Host "  $($_.Name.PadRight(30)) CPU: $([math]::Round($_.CPU, 2)) sec"
        }
        Write-Host ""
        
        # Top 5 Memory processes
        Write-Host "TOP 5 MEMORY PROCESSES:" -ForegroundColor Yellow
        Get-Process | Sort-Object WorkingSet -Descending | Select-Object -First 5 | ForEach-Object {
            $memMB = [math]::Round($_.WorkingSet / 1MB, 2)
            Write-Host "  $($_.Name.PadRight(30)) Memory: $memMB MB"
        }
        Write-Host ""
        
        # Service status
        $services = Get-Service
        $runningCount = ($services | Where-Object { $_.Status -eq "Running" }).Count
        $stoppedCount = ($services | Where-Object { $_.Status -eq "Stopped" }).Count
        
        Write-Host "SERVICES:" -ForegroundColor Yellow
        Write-Host "  Running: $runningCount"
        Write-Host "  Stopped: $stoppedCount"
        Write-Host ""
        
        Write-Host "Press Ctrl+C to exit..." -ForegroundColor Gray
        Start-Sleep -Seconds $RefreshSeconds
    }
}

# Usage
# Show-PerformanceDashboard -RefreshSeconds 3

# Get service from remote computer
Get-Service -Name "Spooler" -ComputerName "Server01"

# Get multiple services from remote computer
Get-Service -ComputerName "Server01" | Where-Object { $_.Status -eq "Running" }

# Using WMI for remote service management
$service = Get-WmiObject Win32_Service -ComputerName "Server01" -Filter "Name='Spooler'"
$service | Select-Object Name, State, StartMode

# Start service remotely
(Get-WmiObject Win32_Service -ComputerName "Server01" -Filter "Name='Spooler'").StartService()

# Stop service remotely
(Get-WmiObject Win32_Service -ComputerName "Server01" -Filter "Name='Spooler'").StopService()

# Change startup type remotely
$service = Get-WmiObject Win32_Service -ComputerName "Server01" -Filter "Name='Spooler'"
$service.ChangeStartMode("Automatic")

# Get processes from remote computer using WMI
Get-WmiObject Win32_Process -ComputerName "Server01" | 
    Select-Object ProcessId, Name, @{Name="Memory(MB)";Expression={[math]::Round($_.WorkingSetSize/1MB,2)}}

# Get specific process remotely
Get-WmiObject Win32_Process -ComputerName "Server01" -Filter "Name='notepad.exe'"

# Start process remotely
Invoke-WmiMethod -Class Win32_Process -Name Create -ArgumentList "notepad.exe" -ComputerName "Server01"

# Stop process remotely
$process = Get-WmiObject Win32_Process -ComputerName "Server01" -Filter "Name='notepad.exe'"
$process.Terminate()

# Using PowerShell Remoting (more powerful)
Invoke-Command -ComputerName "Server01" -ScriptBlock {
    Get-Process | Sort-Object WorkingSet -Descending | Select-Object -First 10
}

# Get operating system information
Get-CimInstance -ClassName Win32_OperatingSystem

# Get computer system information
Get-CimInstance -ClassName Win32_ComputerSystem

# Get BIOS information
Get-CimInstance -ClassName Win32_BIOS

# Get processor information
Get-CimInstance -ClassName Win32_Processor

# Filter using -Filter parameter (server-side filtering - faster)
Get-CimInstance -ClassName Win32_Service -Filter "State = 'Running'"

# Filter stopped services
Get-CimInstance -ClassName Win32_Service -Filter "State = 'Stopped' AND StartMode = 'Auto'"

# Get specific process by name
Get-CimInstance -ClassName Win32_Process -Filter "Name = 'notepad.exe'"

# Filter using Where-Object (client-side filtering)
Get-CimInstance -ClassName Win32_LogicalDisk | Where-Object {$_.DriveType -eq 3}

# Select specific properties
Get-CimInstance -ClassName Win32_OperatingSystem | 
    Select-Object Caption, Version, BuildNumber, OSArchitecture, LastBootUpTime

# Get disk information with selected properties
Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DriveType = 3" |
    Select-Object DeviceID, VolumeName, 
        @{Name="SizeGB";Expression={[math]::Round($_.Size/1GB,2)}},
        @{Name="FreeGB";Expression={[math]::Round($_.FreeSpace/1GB,2)}},
        @{Name="UsedPercent";Expression={[math]::Round((($_.Size-$_.FreeSpace)/$_.Size)*100,2)}}

# Get CPU details
Get-CimInstance -ClassName Win32_Processor | 
    Select-Object Name, NumberOfCores, NumberOfLogicalProcessors, MaxClockSpeed

# Get RAM information
Get-CimInstance -ClassName Win32_PhysicalMemory | 
    Select-Object Manufacturer, Capacity, Speed, DeviceLocator |
    Format-Table -AutoSize

# Get disk drive information
Get-CimInstance -ClassName Win32_DiskDrive | 
    Select-Object Model, SerialNumber, 
        @{Name="SizeGB";Expression={[math]::Round($_.Size/1GB,2)}},
        InterfaceType

# Get network adapter configuration
Get-CimInstance -ClassName Win32_NetworkAdapterConfiguration -Filter "IPEnabled = True" |
    Select-Object Description, IPAddress, IPSubnet, DefaultIPGateway, DNSServerSearchOrder

# Create a CIM session to local computer
$session = New-CimSession

# Create a CIM session to remote computer
$session = New-CimSession -ComputerName "Server01"

# Create session with credentials
$cred = Get-Credential
$session = New-CimSession -ComputerName "Server01" -Credential $cred

# Use the session for queries
Get-CimInstance -ClassName Win32_OperatingSystem -CimSession $session

# Close the session when done
Remove-CimSession -CimSession $session

# Create sessions to multiple computers
$computers = "Server01", "Server02", "Server03"
$sessions = New-CimSession -ComputerName $computers

# Query all computers at once
$osInfo = Get-CimInstance -ClassName Win32_OperatingSystem -CimSession $sessions

# Display results
$osInfo | Select-Object PSComputerName, Caption, Version, LastBootUpTime | Format-Table -AutoSize

# Clean up sessions
$sessions | Remove-CimSession

# Get all methods for a class
Get-CimClass -ClassName Win32_Process | Select-Object -ExpandProperty CimClassMethods

# Get methods for Win32_Service
Get-CimClass -ClassName Win32_Service | Select-Object -ExpandProperty CimClassMethods

# View method details
$class = Get-CimClass -ClassName Win32_Process
$class.CimClassMethods["Create"]

# Start a process using CIM
Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{
    CommandLine = "notepad.exe"
}

# Stop a process
$process = Get-CimInstance -ClassName Win32_Process -Filter "Name = 'notepad.exe'"
Invoke-CimMethod -InputObject $process -MethodName Terminate

# Restart a service
$service = Get-CimInstance -ClassName Win32_Service -Filter "Name = 'Spooler'"
Invoke-CimMethod -InputObject $service -MethodName StopService
Start-Sleep -Seconds 2
Invoke-CimMethod -InputObject $service -MethodName StartService

# OLD WAY (WMI) - Don't use for new scripts
Get-WmiObject -Class Win32_OperatingSystem
Get-WmiObject -Class Win32_Service -Filter "State = 'Running'"
Invoke-WmiMethod -Class Win32_Process -Name Create -ArgumentList "notepad.exe"

# NEW WAY (CIM) - Use this instead
Get-CimInstance -ClassName Win32_OperatingSystem
Get-CimInstance -ClassName Win32_Service -Filter "State = 'Running'"
Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{CommandLine="notepad.exe"}

function Get-SystemInventory {
    param(
        [string[]]$ComputerName = $env:COMPUTERNAME
    )
    
    $results = @()
    
    foreach ($computer in $ComputerName) {
        try {
            # Create CIM session
            $session = New-CimSession -ComputerName $computer -ErrorAction Stop
            
            # Get system information
            $cs = Get-CimInstance -ClassName Win32_ComputerSystem -CimSession $session
            $os = Get-CimInstance -ClassName Win32_OperatingSystem -CimSession $session
            $cpu = Get-CimInstance -ClassName Win32_Processor -CimSession $session | Select-Object -First 1
            $memory = Get-CimInstance -ClassName Win32_PhysicalMemory -CimSession $session
            $disk = Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DriveType = 3" -CimSession $session
            
            # Calculate total RAM
            $totalRAM = ($memory | Measure-Object -Property Capacity -Sum).Sum / 1GB
            
            # Create inventory object
            $inventory = [PSCustomObject]@{
                ComputerName = $computer
                Manufacturer = $cs.Manufacturer
                Model = $cs.Model
                SerialNumber = (Get-CimInstance -ClassName Win32_BIOS -CimSession $session).SerialNumber
                OS = $os.Caption
                OSVersion = $os.Version
                OSArchitecture = $os.OSArchitecture
                LastBootTime = $os.LastBootUpTime
                Processor = $cpu.Name
                Cores = $cpu.NumberOfCores
                LogicalProcessors = $cpu.NumberOfLogicalProcessors
                TotalRAM_GB = [math]::Round($totalRAM, 2)
                Disks = ($disk | ForEach-Object {
                    "$($_.DeviceID) $([math]::Round($_.Size/1GB,2))GB"
                }) -join ", "
                Status = "Success"
            }
            
            $results += $inventory
            
            # Clean up
            Remove-CimSession -CimSession $session
        }
        catch {
            $results += [PSCustomObject]@{
                ComputerName = $computer
                Status = "Failed: $($_.Exception.Message)"
            }
        }
    }
    
    return $results
}

# Usage
$inventory = Get-SystemInventory -ComputerName "localhost"
$inventory | Format-List

# Export to CSV
# $inventory | Export-Csv -Path "C:\Inventory.csv" -NoTypeInformation

function Get-DiskSpaceReport {
    param(
        [string[]]$ComputerName = $env:COMPUTERNAME,
        [int]$WarningThreshold = 20,
        [int]$CriticalThreshold = 10
    )
    
    $report = @()
    
    foreach ($computer in $ComputerName) {
        try {
            $session = New-CimSession -ComputerName $computer -ErrorAction Stop
            
            # Get logical disks (Type 3 = Local Disk)
            $disks = Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DriveType = 3" -CimSession $session
            
            foreach ($disk in $disks) {
                $freePercent = [math]::Round(($disk.FreeSpace / $disk.Size) * 100, 2)
                
                # Determine status
                $status = switch ($freePercent) {
                    {$_ -le $CriticalThreshold} { "CRITICAL" }
                    {$_ -le $WarningThreshold} { "WARNING" }
                    default { "OK" }
                }
                
                $diskInfo = [PSCustomObject]@{
                    ComputerName = $computer
                    Drive = $disk.DeviceID
                    VolumeName = $disk.VolumeName
                    SizeGB = [math]::Round($disk.Size / 1GB, 2)
                    FreeGB = [math]::Round($disk.FreeSpace / 1GB, 2)
                    UsedGB = [math]::Round(($disk.Size - $disk.FreeSpace) / 1GB, 2)
                    FreePercent = $freePercent
                    Status = $status
                }
                
                $report += $diskInfo
            }
            
            Remove-CimSession -CimSession $session
        }
        catch {
            Write-Warning "Failed to query $computer: $_"
        }
    }
    
    return $report
}

# Usage
$diskReport = Get-DiskSpaceReport -ComputerName "localhost" -WarningThreshold 20 -CriticalThreshold 10

# Display with color coding
$diskReport | ForEach-Object {
    $color = switch ($_.Status) {
        "CRITICAL" { "Red" }
        "WARNING" { "Yellow" }
        default { "Green" }
    }
    Write-Host "$($_.ComputerName) - $($_.Drive) - $($_.FreePercent)% free - $($_.Status)" -ForegroundColor $color
}

# Export critical/warning disks
$diskReport | Where-Object {$_.Status -ne "OK"} | Export-Csv -Path "C:\DiskAlerts.csv" -NoTypeInformation

function Get-NetworkConfiguration {
    param(
        [string]$ComputerName = $env:COMPUTERNAME
    )
    
    try {
        $session = New-CimSession -ComputerName $ComputerName -ErrorAction Stop
        
        # Get enabled network adapters
        $adapters = Get-CimInstance -ClassName Win32_NetworkAdapterConfiguration -Filter "IPEnabled = True" -CimSession $session
        
        $results = @()
        
        foreach ($adapter in $adapters) {
            $adapterInfo = [PSCustomObject]@{
                ComputerName = $ComputerName
                Description = $adapter.Description
                MACAddress = $adapter.MACAddress
                IPAddress = $adapter.IPAddress -join ", "
                SubnetMask = $adapter.IPSubnet -join ", "
                DefaultGateway = $adapter.DefaultIPGateway -join ", "
                DNSServers = $adapter.DNSServerSearchOrder -join ", "
                DHCPEnabled = $adapter.DHCPEnabled
                DHCPServer = $adapter.DHCPServer
            }
            
            $results += $adapterInfo
        }
        
        Remove-CimSession -CimSession $session
        
        return $results
    }
    catch {
        Write-Error "Failed to get network configuration: $_"
    }
}

# Usage
$netConfig = Get-NetworkConfiguration
$netConfig | Format-List

function Get-ServiceDependencies {
    param(
        [Parameter(Mandatory=$true)]
        [string]$ServiceName,
        [string]$ComputerName = $env:COMPUTERNAME
    )
    
    try {
        $session = New-CimSession -ComputerName $ComputerName -ErrorAction Stop
        
        # Get the service
        $service = Get-CimInstance -ClassName Win32_Service -Filter "Name = '$ServiceName'" -CimSession $session
        
        if (-not $service) {
            Write-Warning "Service '$ServiceName' not found on $ComputerName"
            return
        }
        
        Write-Host "`n=== Service Information ===" -ForegroundColor Cyan
        Write-Host "Name: $($service.Name)"
        Write-Host "Display Name: $($service.DisplayName)"
        Write-Host "State: $($service.State)"
        Write-Host "Start Mode: $($service.StartMode)"
        
        # Get services this service depends on
        Write-Host "`n=== Services This Depends On ===" -ForegroundColor Cyan
        $query = "SELECT * FROM Win32_DependentService WHERE Dependent = 'Win32_Service.Name=''$ServiceName'''"
        $dependencies = Get-CimInstance -Query $query -CimSession $session
        
        if ($dependencies) {
            foreach ($dep in $dependencies) {
                $depService = Get-CimInstance -ClassName Win32_Service -Filter "Name = '$($dep.Antecedent.Name)'" -CimSession $session
                Write-Host "  - $($depService.DisplayName) ($($depService.Name)) - State: $($depService.State)"
            }
        } else {
            Write-Host "  No dependencies"
        }
        
        # Get services that depend on this service
        Write-Host "`n=== Services That Depend On This ===" -ForegroundColor Cyan
        $query = "SELECT * FROM Win32_DependentService WHERE Antecedent = 'Win32_Service.Name=''$ServiceName'''"
        $dependents = Get-CimInstance -Query $query -CimSession $session
        
        if ($dependents) {
            foreach ($dep in $dependents) {
                $depService = Get-CimInstance -ClassName Win32_Service -Filter "Name = '$($dep.Dependent.Name)'" -CimSession $session
                Write-Host "  - $($depService.DisplayName) ($($depService.Name)) - State: $($depService.State)"
            }
        } else {
            Write-Host "  No dependent services"
        }
        
        Remove-CimSession -CimSession $session
    }
    catch {
        Write-Error "Failed to get service dependencies: $_"
    }
}

# Usage
Get-ServiceDependencies -ServiceName "Spooler"
Get-ServiceDependencies -ServiceName "W32Time"

# SLOW - Client-side filtering
Measure-Command {
    Get-CimInstance -ClassName Win32_Service | Where-Object {$_.State -eq 'Running'}
}

# FAST - Server-side filtering
Measure-Command {
    Get-CimInstance -ClassName Win32_Service -Filter "State = 'Running'"
}

# SLOW - Getting all properties
Measure-Command {
    Get-CimInstance -ClassName Win32_Process
}

# FAST - Getting only needed properties
Measure-Command {
    Get-CimInstance -ClassName Win32_Process | Select-Object Name, ProcessId, WorkingSetSize
}

# Enable PowerShell Remoting (run as Administrator)
Enable-PSRemoting -Force

# What Enable-PSRemoting does:
# 1. Starts WinRM service
# 2. Sets WinRM service to automatic startup
# 3. Creates listener on HTTP (port 5985)
# 4. Enables firewall rules for WS-Management
# 5. Registers PowerShell session configurations

# Check if WinRM service is running
Get-Service WinRM

# Test WinRM configuration
Test-WSMan

# Test connection to remote computer
Test-WSMan -ComputerName "Server01"

# View WinRM configuration
winrm get winrm/config

# View current trusted hosts
Get-Item WSMan:\localhost\Client\TrustedHosts

# Add specific computer to trusted hosts
Set-Item WSMan:\localhost\Client\TrustedHosts -Value "Server01"

# Add multiple computers
Set-Item WSMan:\localhost\Client\TrustedHosts -Value "Server01,Server02,Server03"

# Add all computers (use with caution!)
Set-Item WSMan:\localhost\Client\TrustedHosts -Value "*"

# Append to existing list
$current = (Get-Item WSMan:\localhost\Client\TrustedHosts).Value
Set-Item WSMan:\localhost\Client\TrustedHosts -Value "$current,Server04"

# Start interactive session to remote computer
Enter-PSSession -ComputerName "Server01"

# With credentials (for workgroup or different domain)
$cred = Get-Credential
Enter-PSSession -ComputerName "Server01" -Credential $cred

# Using existing session
$session = New-PSSession -ComputerName "Server01"
Enter-PSSession -Session $session

# Exit interactive session
Exit-PSSession

# Or use 'exit' command

# Run command on single remote computer
Invoke-Command -ComputerName "Server01" -ScriptBlock {
    Get-Service -Name "Spooler"
}

# Run command on multiple computers
Invoke-Command -ComputerName "Server01", "Server02", "Server03" -ScriptBlock {
    Get-Process | Where-Object {$_.CPU -gt 100}
}

# Run command with credentials
$cred = Get-Credential
Invoke-Command -ComputerName "Server01" -Credential $cred -ScriptBlock {
    Get-EventLog -LogName System -Newest 10
}

# Run local script on remote computers
Invoke-Command -ComputerName "Server01", "Server02" -FilePath "C:\Scripts\Maintenance.ps1"

# Using -ArgumentList parameter
$serviceName = "Spooler"
Invoke-Command -ComputerName "Server01" -ScriptBlock {
    param($Service)
    Get-Service -Name $Service
} -ArgumentList $serviceName

# Multiple arguments
$service = "Spooler"
$status = "Running"
Invoke-Command -ComputerName "Server01" -ScriptBlock {
    param($ServiceName, $ServiceStatus)
    Get-Service -Name $ServiceName | Where-Object {$_.Status -eq $ServiceStatus}
} -ArgumentList $service, $status

# Using $using: scope modifier (PowerShell 3.0+)
$serviceName = "Spooler"
Invoke-Command -ComputerName "Server01" -ScriptBlock {
    Get-Service -Name $using:serviceName
}

# Results include PSComputerName property
$results = Invoke-Command -ComputerName "Server01", "Server02", "Server03" -ScriptBlock {
    Get-Service -Name "Spooler"
}

# Display with computer name
$results | Select-Object PSComputerName, Name, Status | Format-Table -AutoSize

# Filter results by computer
$results | Where-Object {$_.PSComputerName -eq "Server01"}

# Export results
$results | Export-Csv -Path "C:\Reports\ServiceStatus.csv" -NoTypeInformation

# Create single session
$session = New-PSSession -ComputerName "Server01"

# Create multiple sessions
$sessions = New-PSSession -ComputerName "Server01", "Server02", "Server03"

# Create session with credentials
$cred = Get-Credential
$session = New-PSSession -ComputerName "Server01" -Credential $cred

# Create session with custom name
$session = New-PSSession -ComputerName "Server01" -Name "MyServerSession"

# View active sessions
Get-PSSession

# View sessions on specific computer
Get-PSSession -ComputerName "Server01"

# Create session
$session = New-PSSession -ComputerName "Server01"

# Run multiple commands using same session
Invoke-Command -Session $session -ScriptBlock {
    $data = Get-Process
    $data | Where-Object {$_.CPU -gt 100}
}

Invoke-Command -Session $session -ScriptBlock {
    # Variables from previous command are still available
    $data | Measure-Object -Property WorkingSet -Sum
}

# Enter interactive mode with session
Enter-PSSession -Session $session

# Close session when done
Remove-PSSession -Session $session

# Or close all sessions
Get-PSSession | Remove-PSSession

# Run remote command as background job
$job = Invoke-Command -ComputerName "Server01", "Server02" -ScriptBlock {
    Get-EventLog -LogName System -Newest 1000
} -AsJob

# Check job status
Get-Job

# Wait for job to complete
Wait-Job -Job $job

# Get job results
$results = Receive-Job -Job $job

# Remove job
Remove-Job -Job $job

# Run with job name
Invoke-Command -ComputerName "Server01" -ScriptBlock {
    Get-Process
} -AsJob -JobName "ProcessInventory"

# Default throttle limit is 32 concurrent connections
Invoke-Command -ComputerName (Get-Content "C:\Servers.txt") -ScriptBlock {
    Get-Service
}

# Set custom throttle limit
Invoke-Command -ComputerName (Get-Content "C:\Servers.txt") -ScriptBlock {
    Get-Service
} -ThrottleLimit 10

# Process large list efficiently
$servers = 1..100 | ForEach-Object { "Server$_" }
Invoke-Command -ComputerName $servers -ScriptBlock {
    Get-WmiObject Win32_OperatingSystem
} -ThrottleLimit 20

# Create session
$session = New-PSSession -ComputerName "Server01"

# Start long-running command
Invoke-Command -Session $session -ScriptBlock {
    Start-Sleep -Seconds 300
    Get-Process
} -AsJob

# Disconnect session (keeps running on remote computer)
Disconnect-PSSession -Session $session

# Later, reconnect to session
$session = Connect-PSSession -ComputerName "Server01"

# Or get disconnected sessions
$disconnected = Get-PSSession -ComputerName "Server01" -State Disconnected
Connect-PSSession -Session $disconnected[0]

function Get-ServerHealthCheck {
    param(
        [Parameter(Mandatory=$true)]
        [string[]]$ComputerName,
        [PSCredential]$Credential
    )
    
    $results = Invoke-Command -ComputerName $ComputerName -Credential $Credential -ScriptBlock {
        # Get system information
        $os = Get-CimInstance -ClassName Win32_OperatingSystem
        $cs = Get-CimInstance -ClassName Win32_ComputerSystem
        $disk = Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DriveType = 3"
        
        # Calculate uptime
        $uptime = (Get-Date) - $os.LastBootUpTime
        
        # Get CPU usage
        $cpu = Get-CimInstance -ClassName Win32_Processor
        $cpuLoad = ($cpu | Measure-Object -Property LoadPercentage -Average).Average
        
        # Memory usage
        $memoryUsedPercent = [math]::Round((($os.TotalVisibleMemorySize - $os.FreePhysicalMemory) / $os.TotalVisibleMemorySize) * 100, 2)
        
        # Disk space
        $diskInfo = $disk | ForEach-Object {
            $freePercent = [math]::Round(($_.FreeSpace / $_.Size) * 100, 2)
            [PSCustomObject]@{
                Drive = $_.DeviceID
                FreePercent = $freePercent
                Status = if ($freePercent -lt 10) { "CRITICAL" } elseif ($freePercent -lt 20) { "WARNING" } else { "OK" }
            }
        }
        
        # Critical services
        $criticalServices = @("WinRM", "W32Time", "EventLog")
        $serviceStatus = Get-Service -Name $criticalServices -ErrorAction SilentlyContinue
        $stoppedServices = $serviceStatus | Where-Object {$_.Status -ne "Running"}
        
        # Return health report
        [PSCustomObject]@{
            ComputerName = $env:COMPUTERNAME
            OS = $os.Caption
            UptimeDays = [math]::Round($uptime.TotalDays, 2)
            CPULoad = $cpuLoad
            MemoryUsedPercent = $memoryUsedPercent
            DiskStatus = ($diskInfo | Where-Object {$_.Status -ne "OK"}).Count -eq 0
            DiskDetails = $diskInfo
            StoppedCriticalServices = $stoppedServices.Name -join ", "
            OverallStatus = if ($stoppedServices -or ($diskInfo | Where-Object {$_.Status -eq "CRITICAL"})) {
                "CRITICAL"
            } elseif (($diskInfo | Where-Object {$_.Status -eq "WARNING"}) -or $memoryUsedPercent -gt 90) {
                "WARNING"
            } else {
                "HEALTHY"
            }
        }
    } -ErrorAction SilentlyContinue
    
    return $results
}

# Usage
$servers = "Server01", "Server02", "Server03"
$healthCheck = Get-ServerHealthCheck -ComputerName $servers

# Display results
$healthCheck | Format-Table ComputerName, OS, UptimeDays, CPULoad, MemoryUsedPercent, OverallStatus -AutoSize

# Export to HTML report
$healthCheck | ConvertTo-Html -Title "Server Health Report" | Out-File "C:\Reports\ServerHealth.html"

function Install-RemoteSoftware {
    param(
        [Parameter(Mandatory=$true)]
        [string[]]$ComputerName,
        [Parameter(Mandatory=$true)]
        [string]$InstallerPath,
        [string]$Arguments = "/quiet /norestart",
        [PSCredential]$Credential
    )
    
    # Verify installer exists
    if (-not (Test-Path $InstallerPath)) {
        Write-Error "Installer not found: $InstallerPath"
        return
    }
    
    $installerName = Split-Path $InstallerPath -Leaf
    
    $results = Invoke-Command -ComputerName $ComputerName -Credential $Credential -ScriptBlock {
        param($InstallerContent, $InstallerName, $Arguments)
        
        try {
            # Create temp directory
            $tempPath = "C:\Temp\RemoteInstall"
            if (-not (Test-Path $tempPath)) {
                New-Item -Path $tempPath -ItemType Directory -Force | Out-Null
            }
            
            # Save installer
            $localInstaller = Join-Path $tempPath $InstallerName
            [System.IO.File]::WriteAllBytes($localInstaller, $InstallerContent)
            
            # Run installer
            Write-Host "Installing $InstallerName..."
            $process = Start-Process -FilePath $localInstaller -ArgumentList $Arguments -Wait -PassThru -NoNewWindow
            
            # Clean up
            Remove-Item -Path $localInstaller -Force -ErrorAction SilentlyContinue
            
            [PSCustomObject]@{
                ComputerName = $env:COMPUTERNAME
                Status = if ($process.ExitCode -eq 0) { "Success" } else { "Failed" }
                ExitCode = $process.ExitCode
                Message = if ($process.ExitCode -eq 0) { "Installation completed" } else { "Installation failed with exit code $($process.ExitCode)" }
            }
        }
        catch {
            [PSCustomObject]@{
                ComputerName = $env:COMPUTERNAME
                Status = "Error"
                ExitCode = -1
                Message = $_.Exception.Message
            }
        }
    } -ArgumentList ([System.IO.File]::ReadAllBytes($InstallerPath)), $installerName, $Arguments
    
    return $results
}

# Usage
$servers = "Server01", "Server02"
$installer = "C:\Software\MyApp_Setup.msi"
$results = Install-RemoteSoftware -ComputerName $servers -InstallerPath $installer -Arguments "/quiet /norestart"

# Display results
$results | Format-Table ComputerName, Status, ExitCode, Message -AutoSize

function Get-RemoteEventLogs {
    param(
        [Parameter(Mandatory=$true)]
        [string[]]$ComputerName,
        [string]$LogName = "System",
        [int]$Newest = 100,
        [string[]]$EntryType = @("Error", "Warning"),
        [PSCredential]$Credential
    )
    
    $logs = Invoke-Command -ComputerName $ComputerName -Credential $Credential -ScriptBlock {
        param($LogName, $Newest, $EntryType)
        
        try {
            $events = Get-EventLog -LogName $LogName -Newest $Newest -EntryType $EntryType -ErrorAction Stop
            
            $events | ForEach-Object {
                [PSCustomObject]@{
                    ComputerName = $env:COMPUTERNAME
                    TimeGenerated = $_.TimeGenerated
                    EntryType = $_.EntryType
                    Source = $_.Source
                    EventID = $_.EventID
                    Message = $_.Message.Substring(0, [Math]::Min(200, $_.Message.Length))
                }
            }
        }
        catch {
            [PSCustomObject]@{
                ComputerName = $env:COMPUTERNAME
                TimeGenerated = Get-Date
                EntryType = "Error"
                Source = "PowerShell"
                EventID = 0
                Message = "Failed to retrieve logs: $($_.Exception.Message)"
            }
        }
    } -ArgumentList $LogName, $Newest, $EntryType
    
    return $logs
}

# Usage
$servers = "Server01", "Server02", "Server03"
$errorLogs = Get-RemoteEventLogs -ComputerName $servers -LogName "System" -Newest 50 -EntryType "Error"

# Display summary
$errorLogs | Group-Object ComputerName | Select-Object Name, Count

# Export to CSV
$errorLogs | Export-Csv -Path "C:\Reports\RemoteErrors.csv" -NoTypeInformation

# Show recent critical events
$errorLogs | Where-Object {$_.TimeGenerated -gt (Get-Date).AddHours(-24)} | 
    Format-Table ComputerName, TimeGenerated, Source, EventID, Message -AutoSize

function Set-RemoteConfiguration {
    param(
        [Parameter(Mandatory=$true)]
        [string[]]$ComputerName,
        [Parameter(Mandatory=$true)]
        [hashtable]$Configuration,
        [PSCredential]$Credential
    )
    
    $results = Invoke-Command -ComputerName $ComputerName -Credential $Credential -ScriptBlock {
        param($Config)
        
        $changes = @()
        
        try {
            # Example: Set registry values
            if ($Config.ContainsKey("Registry")) {
                foreach ($regItem in $Config.Registry.GetEnumerator()) {
                    $path = $regItem.Value.Path
                    $name = $regItem.Value.Name
                    $value = $regItem.Value.Value
                    $type = $regItem.Value.Type
                    
                    if (-not (Test-Path $path)) {
                        New-Item -Path $path -Force | Out-Null
                    }
                    
                    Set-ItemProperty -Path $path -Name $name -Value $value -Type $type
                    $changes += "Registry: Set $path\$name = $value"
                }
            }
            
            # Example: Configure services
            if ($Config.ContainsKey("Services")) {
                foreach ($svcItem in $Config.Services.GetEnumerator()) {
                    $svcName = $svcItem.Key
                    $svcConfig = $svcItem.Value
                    
                    $service = Get-Service -Name $svcName -ErrorAction SilentlyContinue
                    if ($service) {
                        if ($svcConfig.StartupType) {
                            Set-Service -Name $svcName -StartupType $svcConfig.StartupType
                            $changes += "Service: Set $svcName startup to $($svcConfig.StartupType)"
                        }
                        
                        if ($svcConfig.Status -eq "Running" -and $service.Status -ne "Running") {
                            Start-Service -Name $svcName
                            $changes += "Service: Started $svcName"
                        }
                        elseif ($svcConfig.Status -eq "Stopped" -and $service.Status -ne "Stopped") {
                            Stop-Service -Name $svcName -Force
                            $changes += "Service: Stopped $svcName"
                        }
                    }
                }
            }
            
            # Example: Set environment variables
            if ($Config.ContainsKey("Environment")) {
                foreach ($envItem in $Config.Environment.GetEnumerator()) {
                    [Environment]::SetEnvironmentVariable($envItem.Key, $envItem.Value, "Machine")
                    $changes += "Environment: Set $($envItem.Key) = $($envItem.Value)"
                }
            }
            
            [PSCustomObject]@{
                ComputerName = $env:COMPUTERNAME
                Status = "Success"
                ChangesApplied = $changes.Count
                Changes = $changes -join "; "
            }
        }
        catch {
            [PSCustomObject]@{
                ComputerName = $env:COMPUTERNAME
                Status = "Failed"
                ChangesApplied = 0
                Changes = "Error: $($_.Exception.Message)"
            }
        }
    } -ArgumentList $Configuration
    
    return $results
}

# Usage example
$config = @{
    Services = @{
        "Spooler" = @{
            StartupType = "Automatic"
            Status = "Running"
        }
        "W32Time" = @{
            StartupType = "Automatic"
            Status = "Running"
        }
    }
    Environment = @{
        "COMPANY_NAME" = "MyCompany"
        "APP_ENV" = "Production"
    }
    Registry = @{
        "AppSetting1" = @{
            Path = "HKLM:\SOFTWARE\MyApp"
            Name = "Setting1"
            Value = "Value1"
            Type = "String"
        }
    }
}

$servers = "Server01", "Server02"
$results = Set-RemoteConfiguration -ComputerName $servers -Configuration $config

# Display results
$results | Format-Table ComputerName, Status, ChangesApplied -AutoSize
$results | Select-Object ComputerName, Changes | Format-List

# Test basic connectivity
Test-NetConnection -ComputerName "Server01" -Port 5985

# Test WinRM
Test-WSMan -ComputerName "Server01"

# Check WinRM service on remote computer
Get-Service WinRM -ComputerName "Server01"

# View WinRM listeners
Get-WSManInstance -ResourceURI winrm/config/listener -Enumerate

# Check firewall rules
Get-NetFirewallRule -DisplayName "*Windows Remote Management*"

# Enable detailed logging
Set-Item WSMan:\localhost\Service\Auth\Basic -Value $true
Set-Item WSMan:\localhost\Client\Auth\Basic -Value $true

# View WinRM event logs
Get-EventLog -LogName "Microsoft-Windows-WinRM/Operational" -Newest 50

# Store encrypted credential to file (user-specific encryption)
$cred = Get-Credential
$cred | Export-Clixml -Path "C:\Secure\Credential.xml"

# Load credential from file
$cred = Import-Clixml -Path "C:\Secure\Credential.xml"

# Use credential in remote command
Invoke-Command -ComputerName "Server01" -Credential $cred -ScriptBlock {
    Get-Service
}

# Create credential from secure string
$username = "Domain\User"
$password = ConvertTo-SecureString "P@ssw0rd" -AsPlainText -Force
$cred = New-Object System.Management.Automation.PSCredential($username, $password)

# List currently loaded modules
Get-Module

# List all available modules (installed)
Get-Module -ListAvailable

# Find specific module
Get-Module -Name "Microsoft.PowerShell.*" -ListAvailable

# Get module details
Get-Module -Name "Microsoft.PowerShell.Management" | Format-List

# Import a module
Import-Module -Name "ActiveDirectory"

# Import module from specific path
Import-Module -Name "C:\MyModules\MyModule.psm1"

# Import with specific version
Import-Module -Name "Az" -RequiredVersion "9.0.0"

# Import and force reload (refresh)
Import-Module -Name "MyModule" -Force

# Import specific functions only
Import-Module -Name "MyModule" -Function "Get-CustomData", "Set-CustomData"

# Remove a loaded module
Remove-Module -Name "MyModule"

# Remove all loaded modules
Get-Module | Remove-Module

# Remove with confirmation
Remove-Module -Name "MyModule" -Confirm

# View current module paths
$env:PSModulePath -split ';'

# Common module paths:
# C:\Users\<Username>\Documents\PowerShell\Modules (User)
# C:\Program Files\PowerShell\Modules (All Users)
# C:\Windows\System32\WindowsPowerShell\v1.0\Modules (System)

# Add custom module path (temporary - current session)
$env:PSModulePath += ";C:\MyCustomModules"

# Add custom module path (permanent - user)
$currentPath = [Environment]::GetEnvironmentVariable("PSModulePath", "User")
$newPath = "$currentPath;C:\MyCustomModules"
[Environment]::SetEnvironmentVariable("PSModulePath", $newPath, "User")

# Verify module can be found
Get-Module -Name "MyModule" -ListAvailable

# Create module directory
$modulePath = "$HOME\Documents\PowerShell\Modules\MyFirstModule"
New-Item -Path $modulePath -ItemType Directory -Force

# Create module file
$moduleFile = "$modulePath\MyFirstModule.psm1"

# Module content
$moduleContent = @'
# MyFirstModule.psm1

function Get-Greeting {
    <#
    .SYNOPSIS
        Returns a personalized greeting.
    .DESCRIPTION
        This function returns a greeting message with the specified name.
    .PARAMETER Name
        The name to include in the greeting.
    .EXAMPLE
        Get-Greeting -Name "John"
        Returns: "Hello, John! Welcome to PowerShell modules."
    #>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$Name
    )
    
    return "Hello, $Name! Welcome to PowerShell modules."
}

function Get-SystemInfo {
    <#
    .SYNOPSIS
        Gets basic system information.
    .DESCRIPTION
        Returns computer name, OS, and PowerShell version.
    .EXAMPLE
        Get-SystemInfo
    #>
    [CmdletBinding()]
    param()
    
    [PSCustomObject]@{
        ComputerName = $env:COMPUTERNAME
        UserName = $env:USERNAME
        OS = (Get-CimInstance Win32_OperatingSystem).Caption
        PSVersion = $PSVersionTable.PSVersion.ToString()
        Date = Get-Date
    }
}

# Export functions (make them available when module is imported)
Export-ModuleMember -Function Get-Greeting, Get-SystemInfo
'@

# Save module file
Set-Content -Path $moduleFile -Value $moduleContent -Encoding UTF8

Write-Host "Module created: $moduleFile" -ForegroundColor Green

# Import the module
Import-Module -Name "MyFirstModule" -Force

# Test the functions
Get-Greeting -Name "PowerShell User"
Get-SystemInfo

# View module information
Get-Module -Name "MyFirstModule"

# View exported commands
Get-Command -Module "MyFirstModule"

# Create module manifest
$manifestPath = "$HOME\Documents\PowerShell\Modules\MyFirstModule\MyFirstModule.psd1"

$manifestParams = @{
    Path = $manifestPath
    RootModule = "MyFirstModule.psm1"
    ModuleVersion = "1.0.0"
    Author = "Your Name"
    CompanyName = "Your Company"
    Description = "My first PowerShell module with custom functions"
    PowerShellVersion = "5.1"
    FunctionsToExport = @("Get-Greeting", "Get-SystemInfo")
    CmdletsToExport = @()
    VariablesToExport = @()
    AliasesToExport = @()
    Tags = @("Demo", "Learning", "Tutorial")
    ProjectUri = "https://github.com/yourusername/MyFirstModule"
    LicenseUri = "https://github.com/yourusername/MyFirstModule/LICENSE"
    ReleaseNotes = "Initial release with basic functions"
}

New-ModuleManifest @manifestParams

Write-Host "Manifest created: $manifestPath" -ForegroundColor Green

# Test the manifest file
Test-ModuleManifest -Path "$HOME\Documents\PowerShell\Modules\MyFirstModule\MyFirstModule.psd1"

# Import module using manifest
Import-Module -Name "MyFirstModule" -Force

# View manifest details
Get-Module -Name "MyFirstModule" | Format-List

# Advanced module structure
$advancedModule = @'
# MyAdvancedModule.psm1

# Private function (not exported)
function Get-InternalData {
    param([string]$Value)
    return "Internal: $Value"
}

# Public function (exported)
function Get-PublicData {
    <#
    .SYNOPSIS
        Gets public data using internal helper.
    .PARAMETER Value
        The value to process.
    #>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$Value
    )
    
    # Call private function
    $internal = Get-InternalData -Value $Value
    return "Public: $Value | $internal"
}

# Module initialization code
Write-Verbose "MyAdvancedModule loaded"

# Export only public functions
Export-ModuleMember -Function Get-PublicData
'@

# Save advanced module
$advModulePath = "$HOME\Documents\PowerShell\Modules\MyAdvancedModule"
New-Item -Path $advModulePath -ItemType Directory -Force
Set-Content -Path "$advModulePath\MyAdvancedModule.psm1" -Value $advancedModule -Encoding UTF8

# Module with PowerShell classes
$classModule = @'
# MyClassModule.psm1

# Define a class
class Computer {
    [string]$Name
    [string]$OS
    [datetime]$LastBoot
    
    # Constructor
    Computer([string]$computerName) {
        $this.Name = $computerName
        $os = Get-CimInstance -ClassName Win32_OperatingSystem -ComputerName $computerName
        $this.OS = $os.Caption
        $this.LastBoot = $os.LastBootUpTime
    }
    
    # Method
    [string]GetUptime() {
        $uptime = (Get-Date) - $this.LastBoot
        return "$($uptime.Days) days, $($uptime.Hours) hours"
    }
}

# Function that uses the class
function Get-ComputerObject {
    <#
    .SYNOPSIS
        Creates a Computer object.
    .PARAMETER ComputerName
        The name of the computer.
    #>
    [CmdletBinding()]
    param(
        [string]$ComputerName = $env:COMPUTERNAME
    )
    
    return [Computer]::new($ComputerName)
}

# Export class and function
Export-ModuleMember -Function Get-ComputerObject
'@

# Save class module
$classModulePath = "$HOME\Documents\PowerShell\Modules\MyClassModule"
New-Item -Path $classModulePath -ItemType Directory -Force
Set-Content -Path "$classModulePath\MyClassModule.psm1" -Value $classModule -Encoding UTF8

# Usage example:
# Import-Module MyClassModule
# $pc = Get-ComputerObject
# $pc.GetUptime()

<#
.SYNOPSIS
    Brief description of the script.

.DESCRIPTION
    Detailed description of what the script does.

.PARAMETER ComputerName
    The name of the computer to query.

.PARAMETER LogPath
    Path to the log file.

.EXAMPLE
    .\MyScript.ps1 -ComputerName "Server01" -LogPath "C:\Logs\script.log"
    
.NOTES
    Author: Your Name
    Date: 2024-01-01
    Version: 1.0
    
.LINK
    https://github.com/yourusername/yourrepo
#>

[CmdletBinding()]
param(
    [Parameter(Mandatory=$true, HelpMessage="Enter computer name")]
    [ValidateNotNullOrEmpty()]
    [string]$ComputerName,
    
    [Parameter(Mandatory=$false)]
    [ValidateScript({Test-Path (Split-Path $_)})]
    [string]$LogPath = "$PSScriptRoot\script.log"
)

# Script variables
$ErrorActionPreference = "Stop"
$scriptVersion = "1.0"
$scriptName = $MyInvocation.MyCommand.Name

# Logging function
function Write-Log {
    param(
        [string]$Message,
        [ValidateSet("INFO", "WARNING", "ERROR")]
        [string]$Level = "INFO"
    )
    
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $logMessage = "[$timestamp] [$Level] $Message"
    
    # Write to console
    switch ($Level) {
        "INFO" { Write-Host $logMessage -ForegroundColor Green }
        "WARNING" { Write-Host $logMessage -ForegroundColor Yellow }
        "ERROR" { Write-Host $logMessage -ForegroundColor Red }
    }
    
    # Write to file
    Add-Content -Path $LogPath -Value $logMessage
}

# Main script logic
try {
    Write-Log "Script started: $scriptName v$scriptVersion"
    Write-Log "Target computer: $ComputerName"
    
    # Your script logic here
    $result = Get-CimInstance -ClassName Win32_OperatingSystem -ComputerName $ComputerName
    
    Write-Log "Successfully retrieved information from $ComputerName"
    
    # Return result
    return $result
}
catch {
    Write-Log "Error: $($_.Exception.Message)" -Level ERROR
    throw
}
finally {
    Write-Log "Script completed"
}

# View current execution policy
Get-ExecutionPolicy -List

# Set execution policy (requires admin)
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

# Execution policy levels:
# - Restricted: No scripts allowed
# - AllSigned: Only signed scripts
# - RemoteSigned: Local scripts OK, remote must be signed
# - Unrestricted: All scripts allowed (prompts for remote)
# - Bypass: Nothing blocked, no warnings

# Create self-signed certificate for code signing (development only)
$cert = New-SelfSignedCertificate -Type CodeSigningCert -Subject "CN=PowerShell Code Signing" -CertStoreLocation Cert:\CurrentUser\My

# Sign a script
$scriptPath = "C:\Scripts\MyScript.ps1"
Set-AuthenticodeSignature -FilePath $scriptPath -Certificate $cert

# Verify signature
Get-AuthenticodeSignature -FilePath $scriptPath

# Search for modules
Find-Module -Name "*Azure*"

# Find modules by tag
Find-Module -Tag "Backup"

# Find specific module with details
Find-Module -Name "Pester" | Format-List

# Find modules by command
Find-Module -Command "Get-AzVM"

# Search with wildcard
Find-Module -Name "PowerShell*" | Select-Object Name, Version, Description

# Install module for current user
Install-Module -Name "Pester" -Scope CurrentUser

# Install specific version
Install-Module -Name "Az" -RequiredVersion "9.0.0" -Scope CurrentUser

# Install with force (no prompts)
Install-Module -Name "PSReadLine" -Force -Scope CurrentUser

# Install and accept license
Install-Module -Name "PowerShellGet" -AcceptLicense -Scope CurrentUser

# Install from specific repository
Install-Module -Name "MyModule" -Repository "PSGallery"

# Update specific module
Update-Module -Name "Pester"

# Update all modules
Get-InstalledModule | Update-Module

# Check for available updates
Get-InstalledModule | ForEach-Object {
    $installed = $_
    $available = Find-Module -Name $_.Name -ErrorAction SilentlyContinue
    if ($available -and ($available.Version -gt $installed.Version)) {
        [PSCustomObject]@{
            Name = $installed.Name
            InstalledVersion = $installed.Version
            AvailableVersion = $available.Version
            NeedsUpdate = $true
        }
    }
}

# Uninstall specific module
Uninstall-Module -Name "OldModule"

# Uninstall specific version
Uninstall-Module -Name "Az" -RequiredVersion "8.0.0"

# Uninstall all versions
Get-InstalledModule -Name "Az" -AllVersions | Uninstall-Module

# Uninstall with force
Uninstall-Module -Name "MyModule" -Force

# SysAdminTools.psm1
# A module for common system administration tasks

function Get-DiskSpaceReport {
    <#
    .SYNOPSIS
        Generates disk space report for specified computers.
    #>
    [CmdletBinding()]
    param(
        [string[]]$ComputerName = $env:COMPUTERNAME,
        [int]$WarningThreshold = 20
    )
    
    $results = @()
    
    foreach ($computer in $ComputerName) {
        try {
            $disks = Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DriveType=3" -ComputerName $computer
            
            foreach ($disk in $disks) {
                $freePercent = [math]::Round(($disk.FreeSpace / $disk.Size) * 100, 2)
                
                $results += [PSCustomObject]@{
                    ComputerName = $computer
                    Drive = $disk.DeviceID
                    SizeGB = [math]::Round($disk.Size / 1GB, 2)
                    FreeGB = [math]::Round($disk.FreeSpace / 1GB, 2)
                    FreePercent = $freePercent
                    Status = if ($freePercent -lt $WarningThreshold) { "WARNING" } else { "OK" }
                }
            }
        }
        catch {
            Write-Warning "Failed to query $computer: $_"
        }
    }
    
    return $results
}

function Get-ServiceStatus {
    <#
    .SYNOPSIS
        Gets status of specified services across multiple computers.
    #>
    [CmdletBinding()]
    param(
        [string[]]$ComputerName = $env:COMPUTERNAME,
        [string[]]$ServiceName
    )
    
    $results = @()
    
    foreach ($computer in $ComputerName) {
        foreach ($service in $ServiceName) {
            try {
                $svc = Get-Service -Name $service -ComputerName $computer -ErrorAction Stop
                
                $results += [PSCustomObject]@{
                    ComputerName = $computer
                    ServiceName = $svc.Name
                    DisplayName = $svc.DisplayName
                    Status = $svc.Status
                    StartType = $svc.StartType
                }
            }
            catch {
                $results += [PSCustomObject]@{
                    ComputerName = $computer
                    ServiceName = $service
                    Status = "ERROR: $($_.Exception.Message)"
                }
            }
        }
    }
    
    return $results
}

# Export functions
Export-ModuleMember -Function Get-DiskSpaceReport, Get-ServiceStatus

# UserManagement.psm1
# Module for local user account management

function New-LocalUserAccount {
    <#
    .SYNOPSIS
        Creates a new local user account.
    #>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$UserName,
        
        [Parameter(Mandatory=$true)]
        [SecureString]$Password,
        
        [string]$FullName,
        [string]$Description,
        [switch]$PasswordNeverExpires
    )
    
    try {
        $userParams = @{
            Name = $UserName
            Password = $Password
            FullName = $FullName
            Description = $Description
        }
        
        if ($PasswordNeverExpires) {
            $userParams.PasswordNeverExpires = $true
        }
        
        New-LocalUser @userParams
        Write-Host "User '$UserName' created successfully" -ForegroundColor Green
    }
    catch {
        Write-Error "Failed to create user: $_"
    }
}

function Get-LocalUserInfo {
    <#
    .SYNOPSIS
        Gets detailed information about local users.
    #>
    [CmdletBinding()]
    param(
        [string]$UserName = "*"
    )
    
    Get-LocalUser -Name $UserName | Select-Object Name, Enabled, LastLogon, 
        PasswordRequired, PasswordExpires, Description |
        Format-Table -AutoSize
}

# Export functions
Export-ModuleMember -Function New-LocalUserAccount, Get-LocalUserInfo

# Recommended module folder structure:
# MyModule/
# - MyModule.psd1          # Module manifest
# - MyModule.psm1          # Main module file
# - Public/                # Public functions (exported)
#   - Get-Something.ps1
#   - Set-Something.ps1
# - Private/               # Private functions (internal)
#   - Helper-Function.ps1
# - Classes/               # PowerShell classes
#   - MyClass.ps1
# - Tests/                 # Pester tests
#   - MyModule.Tests.ps1
# - README.md              # Documentation
# - LICENSE                # License file

# Example of loading structure in .psm1:
# Get public and private function files
$Public = @(Get-ChildItem -Path $PSScriptRoot\Public\*.ps1 -ErrorAction SilentlyContinue)
$Private = @(Get-ChildItem -Path $PSScriptRoot\Private\*.ps1 -ErrorAction SilentlyContinue)

# Dot source the files
foreach ($import in @($Public + $Private)) {
    try {
        . $import.FullName
    }
    catch {
        Write-Error "Failed to import function $($import.FullName): $_"
    }
}

# Export public functions
Export-ModuleMember -Function $Public.BaseName

function Get-AdvancedExample {
    [CmdletBinding(SupportsShouldProcess=$true)]
    param(
        [Parameter(Mandatory=$true, 
                   ValueFromPipeline=$true,
                   ValueFromPipelineByPropertyName=$true,
                   Position=0,
                   HelpMessage="Enter computer name")]
        [ValidateNotNullOrEmpty()]
        [Alias("CN","MachineName")]
        [string[]]$ComputerName,
        
        [Parameter(Mandatory=$false)]
        [ValidateSet("Running","Stopped","All")]
        [string]$Status = "All",
        
        [Parameter(Mandatory=$false)]
        [ValidateRange(1,100)]
        [int]$MaxResults = 10,
        
        [Parameter(Mandatory=$false)]
        [ValidateScript({Test-Path $_})]
        [string]$LogPath = "C:\Logs",
        
        [switch]$Detailed
    )
    
    begin {
        Write-Verbose "Starting function execution"
        $results = @()
    }
    
    process {
        foreach ($computer in $ComputerName) {
            if ($PSCmdlet.ShouldProcess($computer, "Get information")) {
                Write-Verbose "Processing $computer"
                
                try {
                    # Your logic here
                    $result = [PSCustomObject]@{
                        ComputerName = $computer
                        Status = $Status
                        Timestamp = Get-Date
                    }
                    
                    $results += $result
                }
                catch {
                    Write-Error "Failed to process $computer: $_"
                }
            }
        }
    }
    
    end {
        Write-Verbose "Completed processing $($results.Count) items"
        return $results
    }
}

# Usage examples
Get-AdvancedExample -ComputerName "Server01" -Verbose
Get-AdvancedExample -ComputerName "Server01" -Status "Running" -WhatIf
"Server01","Server02" | Get-AdvancedExample -Detailed

function Get-DynamicParameterExample {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [ValidateSet("Computer","User","Service")]
        [string]$Type
    )
    
    DynamicParam {
        # Create parameter dictionary
        $paramDictionary = New-Object System.Management.Automation.RuntimeDefinedParameterDictionary
        
        # Add dynamic parameter based on Type
        if ($Type -eq "Computer") {
            $paramName = "ComputerName"
            $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute]
            
            $paramAttribute = New-Object System.Management.Automation.ParameterAttribute
            $paramAttribute.Mandatory = $true
            $attributeCollection.Add($paramAttribute)
            
            $validateSetAttribute = New-Object System.Management.Automation.ValidateSetAttribute("Server01","Server02","Server03")
            $attributeCollection.Add($validateSetAttribute)
            
            $runtimeParameter = New-Object System.Management.Automation.RuntimeDefinedParameter($paramName, [string], $attributeCollection)
            $paramDictionary.Add($paramName, $runtimeParameter)
        }
        elseif ($Type -eq "Service") {
            $paramName = "ServiceName"
            $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute]
            
            $paramAttribute = New-Object System.Management.Automation.ParameterAttribute
            $paramAttribute.Mandatory = $true
            $attributeCollection.Add($paramAttribute)
            
            $runtimeParameter = New-Object System.Management.Automation.RuntimeDefinedParameter($paramName, [string], $attributeCollection)
            $paramDictionary.Add($paramName, $runtimeParameter)
        }
        
        return $paramDictionary
    }
    
    process {
        Write-Host "Type: $Type"
        
        if ($Type -eq "Computer") {
            Write-Host "Computer: $($PSBoundParameters['ComputerName'])"
        }
        elseif ($Type -eq "Service") {
            Write-Host "Service: $($PSBoundParameters['ServiceName'])"
        }
    }
}

# Usage - Notice how available parameters change based on Type
Get-DynamicParameterExample -Type Computer -ComputerName "Server01"
Get-DynamicParameterExample -Type Service -ServiceName "Spooler"

# Match operator -match
"Hello World" -match "World"  # Returns True
"[email protected]" -match "\w+@\w+\.\w+"  # Email pattern

# Case-sensitive match
"Hello" -cmatch "hello"  # Returns False
"Hello" -match "hello"   # Returns True (case-insensitive)

# Extract matches using $Matches
$text = "My phone is 555-1234"
if ($text -match "(\d{3})-(\d{4})") {
    Write-Host "Full match: $($Matches[0])"
    Write-Host "Area code: $($Matches[1])"
    Write-Host "Number: $($Matches[2])"
}

# Replace using -replace
$text = "Hello World"
$text -replace "World", "PowerShell"  # Returns "Hello PowerShell"

# Remove all digits
"abc123def456" -replace "\d", ""  # Returns "abcdef"

# Multiple replacements
$text = "The quick brown fox"
$text -replace "quick|brown", "REPLACED"

# Validate email address
function Test-EmailAddress {
    param([string]$Email)
    $Email -match "^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$"
}

Test-EmailAddress "[email protected]"  # True
Test-EmailAddress "invalid.email"     # False

# Validate IP address
function Test-IPAddress {
    param([string]$IP)
    $IP -match "^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
}

Test-IPAddress "192.168.1.1"    # True
Test-IPAddress "999.999.999.999"  # False

# Extract phone numbers from text
$text = "Call me at 555-1234 or 555-5678"
$phoneNumbers = [regex]::Matches($text, "\d{3}-\d{4}")
foreach ($match in $phoneNumbers) {
    Write-Host "Found: $($match.Value)"
}

# Parse log file entries
$logLine = "2024-01-15 14:30:45 ERROR: Connection failed"
if ($logLine -match "^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}) (\w+): (.+)$") {
    $date = $Matches[1]
    $time = $Matches[2]
    $level = $Matches[3]
    $message = $Matches[4]
    
    Write-Host "Date: $date"
    Write-Host "Time: $time"
    Write-Host "Level: $level"
    Write-Host "Message: $message"
}

# Clean up text - remove special characters
$text = "Hello! @World# 123$"
$cleaned = $text -replace "[^\w\s]", ""
Write-Host $cleaned  # "Hello World 123"

# Extract version numbers
$text = "Version 3.14.159 is available"
if ($text -match "Version (\d+\.\d+\.\d+)") {
    Write-Host "Version found: $($Matches[1])"
}

# Start a simple background job
$job = Start-Job -ScriptBlock {
    Get-Process | Where-Object {$_.CPU -gt 10}
}

# Check job status
Get-Job

# Wait for job to complete
Wait-Job -Job $job

# Get job results
$results = Receive-Job -Job $job

# Clean up
Remove-Job -Job $job

# Start multiple jobs
$computers = "Server01", "Server02", "Server03"
$jobs = @()

foreach ($computer in $computers) {
    $jobs += Start-Job -ScriptBlock {
        param($comp)
        Test-Connection -ComputerName $comp -Count 2 -Quiet
    } -ArgumentList $computer
}

# Wait for all jobs
$jobs | Wait-Job

# Get all results
$jobs | Receive-Job

# Clean up all jobs
$jobs | Remove-Job

# Modern parallel processing (PowerShell 7+)
$computers = 1..10 | ForEach-Object { "Server$_" }

# Process in parallel with throttle limit
$results = $computers | ForEach-Object -Parallel {
    [PSCustomObject]@{
        ComputerName = $_
        Online = Test-Connection -ComputerName $_ -Count 1 -Quiet
        Timestamp = Get-Date
    }
} -ThrottleLimit 5

$results | Format-Table -AutoSize

# Parallel file processing
$files = Get-ChildItem -Path "C:\Logs" -Filter "*.log"

$files | ForEach-Object -Parallel {
    $content = Get-Content -Path $_.FullName
    $errorCount = ($content | Select-String -Pattern "ERROR").Count
    
    [PSCustomObject]@{
        FileName = $_.Name
        ErrorCount = $errorCount
        Size = $_.Length
    }
} -ThrottleLimit 10

function Get-ServerHealthParallel {
    param(
        [string[]]$ComputerName,
        [int]$ThrottleLimit = 10
    )
    
    $results = $ComputerName | ForEach-Object -Parallel {
        $computer = $_
        
        try {
            # Test connectivity
            $online = Test-Connection -ComputerName $computer -Count 1 -Quiet -ErrorAction Stop
            
            if ($online) {
                # Get system info
                $os = Get-CimInstance -ClassName Win32_OperatingSystem -ComputerName $computer -ErrorAction Stop
                $cs = Get-CimInstance -ClassName Win32_ComputerSystem -ComputerName $computer -ErrorAction Stop
                $disk = Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DriveType=3" -ComputerName $computer -ErrorAction Stop | 
                        Select-Object -First 1
                
                $freePercent = [math]::Round(($disk.FreeSpace / $disk.Size) * 100, 2)
                
                [PSCustomObject]@{
                    ComputerName = $computer
                    Status = "Online"
                    OS = $os.Caption
                    LastBoot = $os.LastBootUpTime
                    TotalRAM_GB = [math]::Round($cs.TotalPhysicalMemory / 1GB, 2)
                    DiskFreePercent = $freePercent
                    Error = $null
                }
            }
            else {
                [PSCustomObject]@{
                    ComputerName = $computer
                    Status = "Offline"
                    Error = "Cannot reach computer"
                }
            }
        }
        catch {
            [PSCustomObject]@{
                ComputerName = $computer
                Status = "Error"
                Error = $_.Exception.Message
            }
        }
    } -ThrottleLimit $ThrottleLimit
    
    return $results
}

# Usage
$servers = 1..20 | ForEach-Object { "Server$_" }
$health = Get-ServerHealthParallel -ComputerName $servers -ThrottleLimit 10
$health | Format-Table -AutoSize

# Define a class
class Server {
    # Properties
    [string]$Name
    [string]$IPAddress
    [string]$OS
    [bool]$IsOnline
    
    # Constructor
    Server([string]$name, [string]$ip) {
        $this.Name = $name
        $this.IPAddress = $ip
        $this.IsOnline = $false
    }
    
    # Methods
    [bool] TestConnection() {
        $this.IsOnline = Test-Connection -ComputerName $this.IPAddress -Count 1 -Quiet
        return $this.IsOnline
    }
    
    [string] GetInfo() {
        return "Server: $($this.Name) - IP: $($this.IPAddress) - Online: $($this.IsOnline)"
    }
}

# Create instances
$server1 = [Server]::new("WebServer01", "192.168.1.10")
$server2 = [Server]::new("DBServer01", "192.168.1.20")

# Use methods
$server1.TestConnection()
Write-Host $server1.GetInfo()

# Access properties
Write-Host "Server name: $($server1.Name)"
Write-Host "Is online: $($server1.IsOnline)"

# Base class
class Computer {
    [string]$Name
    [string]$IPAddress
    [datetime]$LastChecked
    
    Computer([string]$name, [string]$ip) {
        $this.Name = $name
        $this.IPAddress = $ip
    }
    
    [bool] Ping() {
        $this.LastChecked = Get-Date
        return Test-Connection -ComputerName $this.IPAddress -Count 1 -Quiet
    }
    
    [string] ToString() {
        return "$($this.Name) ($($this.IPAddress))"
    }
}

# Derived class
class WindowsServer : Computer {
    [string]$Domain
    [string[]]$Roles
    [int]$RAM_GB
    
    WindowsServer([string]$name, [string]$ip, [string]$domain) : base($name, $ip) {
        $this.Domain = $domain
        $this.Roles = @()
    }
    
    [void] AddRole([string]$role) {
        $this.Roles += $role
    }
    
    [string] GetFullName() {
        return "$($this.Name).$($this.Domain)"
    }
    
    [hashtable] GetInfo() {
        return @{
            Name = $this.Name
            FullName = $this.GetFullName()
            IPAddress = $this.IPAddress
            Domain = $this.Domain
            Roles = $this.Roles -join ", "
            RAM_GB = $this.RAM_GB
            LastChecked = $this.LastChecked
        }
    }
}

# Usage
$server = [WindowsServer]::new("WEB01", "192.168.1.10", "contoso.com")
$server.RAM_GB = 16
$server.AddRole("IIS")
$server.AddRole("WebServer")

if ($server.Ping()) {
    Write-Host "Server is online"
    $info = $server.GetInfo()
    $info.GetEnumerator() | ForEach-Object {
        Write-Host "$($_.Key): $($_.Value)"
    }
}

class UserAccount {
    [string]$Username
    [string]$FullName
    [string]$Email
    [datetime]$CreatedDate
    [bool]$IsActive
    [string[]]$Groups
    
    # Constructor
    UserAccount([string]$username, [string]$fullName, [string]$email) {
        $this.Username = $username
        $this.FullName = $fullName
        $this.Email = $email
        $this.CreatedDate = Get-Date
        $this.IsActive = $true
        $this.Groups = @()
    }
    
    # Validate email format
    hidden [bool] ValidateEmail([string]$email) {
        return $email -match "^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$"
    }
    
    # Add user to group
    [void] AddToGroup([string]$groupName) {
        if ($this.Groups -notcontains $groupName) {
            $this.Groups += $groupName
            Write-Host "Added $($this.Username) to group: $groupName"
        }
        else {
            Write-Warning "$($this.Username) is already in group: $groupName"
        }
    }
    
    # Remove user from group
    [void] RemoveFromGroup([string]$groupName) {
        if ($this.Groups -contains $groupName) {
            $this.Groups = $this.Groups | Where-Object { $_ -ne $groupName }
            Write-Host "Removed $($this.Username) from group: $groupName"
        }
        else {
            Write-Warning "$($this.Username) is not in group: $groupName"
        }
    }
    
    # Disable account
    [void] Disable() {
        $this.IsActive = $false
        Write-Host "Account disabled: $($this.Username)"
    }
    
    # Enable account
    [void] Enable() {
        $this.IsActive = $true
        Write-Host "Account enabled: $($this.Username)"
    }
    
    # Get account summary
    [PSCustomObject] GetSummary() {
        return [PSCustomObject]@{
            Username = $this.Username
            FullName = $this.FullName
            Email = $this.Email
            CreatedDate = $this.CreatedDate
            IsActive = $this.IsActive
            Groups = $this.Groups -join ", "
            DaysSinceCreation = ((Get-Date) - $this.CreatedDate).Days
        }
    }
}

# Usage
$user = [UserAccount]::new("jdoe", "John Doe", "[email protected]")

$user.AddToGroup("Developers")
$user.AddToGroup("RemoteUsers")
$user.AddToGroup("VPN-Access")

Write-Host "`nUser Summary:"
$user.GetSummary() | Format-List

$user.Disable()
$user.Enable()

$user.RemoveFromGroup("VPN-Access")

# Without splatting (hard to read)
Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DriveType=3" -ComputerName "Server01" -ErrorAction Stop

# With splatting (clean and readable)
$params = @{
    ClassName = "Win32_LogicalDisk"
    Filter = "DriveType=3"
    ComputerName = "Server01"
    ErrorAction = "Stop"
}
Get-CimInstance @params

# Conditional splatting
$params = @{
    Path = "C:\Logs"
    Filter = "*.log"
}

if ($Recurse) {
    $params.Add("Recurse", $true)
}

Get-ChildItem @params

# Combining multiple splat hashtables
$commonParams = @{
    ErrorAction = "Stop"
    Verbose = $true
}

$specificParams = @{
    ComputerName = "Server01"
    ClassName = "Win32_Service"
}

Get-CimInstance @commonParams @specificParams

# Here-string (expandable - variables are replaced)
$name = "John"
$message = @"
Hello $name,

This is a multi-line message.
It preserves formatting and indentation.
Variables like $name are expanded.

Regards,
Admin Team
"@

Write-Host $message

# Here-string literal (non-expandable - variables are NOT replaced)
$template = @'
Dear {Name},

Your account {Username} has been created.
Password: {Password}

Please change your password on first login.
'@

# Replace placeholders
$email = $template -replace "{Name}", "John Doe" `
                   -replace "{Username}", "jdoe" `
                   -replace "{Password}", "TempPass123"

Write-Host $email

# SQL query example
$query = @"
SELECT 
    u.Username,
    u.Email,
    u.CreatedDate
FROM Users u
WHERE u.IsActive = 1
    AND u.Department = 'IT'
ORDER BY u.CreatedDate DESC
"@

# HTML template
$htmlReport = @"



    
    


    
Server Status Report
    
Generated: $(Get-Date)
    

        
Server
Status
Uptime
        
    


"@

# Define a script block
$scriptBlock = {
    param($ComputerName)
    
    $os = Get-CimInstance -ClassName Win32_OperatingSystem
    
    [PSCustomObject]@{
        ComputerName = $ComputerName
        OS = $os.Caption
        FreeMemory_GB = [math]::Round($os.FreePhysicalMemory / 1MB, 2)
        LastBoot = $os.LastBootUpTime
    }
}

# Execute locally
& $scriptBlock -ComputerName $env:COMPUTERNAME

# Execute remotely
Invoke-Command -ComputerName "Server01" -ScriptBlock $scriptBlock -ArgumentList "Server01"

# Store script block in variable and reuse
$getServiceInfo = {
    param($ServiceName)
    Get-Service -Name $ServiceName | Select-Object Name, Status, StartType
}

# Use multiple times
& $getServiceInfo -ServiceName "Spooler"
& $getServiceInfo -ServiceName "W32Time"

# Script block with closure (accessing parent scope)
$threshold = 80

$checkDiskSpace = {
    Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DriveType=3" | ForEach-Object {
        $freePercent = ($_.FreeSpace / $_.Size) * 100
        if ($freePercent -lt $using:threshold) {
            Write-Warning "Drive $($_.DeviceID) is low on space: $([math]::Round($freePercent,2))%"
        }
    }
}

Invoke-Command -ComputerName "Server01" -ScriptBlock $checkDiskSpace

# SLOW: Using += to build arrays
Measure-Command {
    $array = @()
    1..10000 | ForEach-Object {
        $array += $_
    }
}

# FAST: Using ArrayList
Measure-Command {
    $arrayList = [System.Collections.ArrayList]@()
    1..10000 | ForEach-Object {
        [void]$arrayList.Add($_)
    }
}

# FASTEST: Using Generic List
Measure-Command {
    $list = [System.Collections.Generic.List[int]]::new()
    1..10000 | ForEach-Object {
        $list.Add($_)
    }
}

# SLOW: Multiple Where-Object filters
Measure-Command {
    Get-Process | 
        Where-Object {$_.CPU -gt 10} | 
        Where-Object {$_.WorkingSet -gt 100MB}
}

# FAST: Combined filter
Measure-Command {
    Get-Process | Where-Object {$_.CPU -gt 10 -and $_.WorkingSet -gt 100MB}
}

# SLOW: ForEach-Object for simple operations
Measure-Command {
    1..10000 | ForEach-Object { $_ * 2 }
}

# FAST: ForEach method
Measure-Command {
    (1..10000).ForEach({ $_ * 2 })
}

# SLOW: String concatenation in loop
Measure-Command {
    $result = ""
    1..1000 | ForEach-Object {
        $result += "Line $_`n"
    }
}

# FAST: StringBuilder
Measure-Command {
    $sb = [System.Text.StringBuilder]::new()
    1..1000 | ForEach-Object {
        [void]$sb.AppendLine("Line $_")
    }
    $result = $sb.ToString()
}

# Trap specific error types
function Test-AdvancedErrorHandling {
    # Trap for specific exception type
    trap [System.IO.FileNotFoundException] {
        Write-Host "File not found: $($_.Exception.Message)" -ForegroundColor Red
        continue  # Continue execution
    }
    
    trap [System.UnauthorizedAccessException] {
        Write-Host "Access denied: $($_.Exception.Message)" -ForegroundColor Red
        break  # Stop execution
    }
    
    # General trap for all other errors
    trap {
        Write-Host "Unexpected error: $($_.Exception.Message)" -ForegroundColor Yellow
        continue
    }
    
    # Code that might throw errors
    Get-Content "C:\NonExistent.txt"
    Get-Content "C:\Windows\System32\config\SAM"  # Access denied
}

# Custom exception class
class CustomException : System.Exception {
    [string]$CustomMessage
    [datetime]$Timestamp
    
    CustomException([string]$message) : base($message) {
        $this.CustomMessage = $message
        $this.Timestamp = Get-Date
    }
}

# Throw custom exception
function Test-CustomException {
    param([int]$Value)
    
    if ($Value -lt 0) {
        throw [CustomException]::new("Value cannot be negative")
    }
    
    Write-Host "Value is valid: $Value"
}

try {
    Test-CustomException -Value -5
}
catch [CustomException] {
    Write-Host "Custom exception caught!"
    Write-Host "Message: $($_.Exception.CustomMessage)"
    Write-Host "Time: $($_.Exception.Timestamp)"
}

function Verb-Noun {
    <#
    .SYNOPSIS
        Brief description of what the function does.
    
    .DESCRIPTION
        Detailed description of the function's purpose and behavior.
    
    .PARAMETER ParameterName
        Description of the parameter.
    
    .EXAMPLE
        Verb-Noun -ParameterName "Value"
        Description of what this example does.
    
    .EXAMPLE
        Verb-Noun -ParameterName "Value" -Verbose
        Another example with verbose output.
    
    .NOTES
        Author: Your Name
        Date: 2024-01-01
        Version: 1.0
    
    .LINK
        https://documentation-url.com
    #>
    
    [CmdletBinding(SupportsShouldProcess=$true)]
    param(
        [Parameter(Mandatory=$true, 
                   ValueFromPipeline=$true,
                   HelpMessage="Enter the parameter value")]
        [ValidateNotNullOrEmpty()]
        [string]$ParameterName,
        
        [Parameter(Mandatory=$false)]
        [ValidateRange(1,100)]
        [int]$Timeout = 30
    )
    
    begin {
        Write-Verbose "Starting $($MyInvocation.MyCommand)"
        # Initialization code
    }
    
    process {
        try {
            if ($PSCmdlet.ShouldProcess($ParameterName, "Perform action")) {
                # Main logic here
                Write-Verbose "Processing $ParameterName"
                
                # Your code here
            }
        }
        catch {
            Write-Error "Error processing $ParameterName: $_"
            throw
        }
    }
    
    end {
        Write-Verbose "Completed $($MyInvocation.MyCommand)"
        # Cleanup code
    }
}

function Write-Log {
    <#
    .SYNOPSIS
        Writes log messages to file and console with timestamps and severity levels.
    #>
    
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$Message,
        
        [Parameter(Mandatory=$false)]
        [ValidateSet('INFO','WARNING','ERROR','DEBUG')]
        [string]$Level = 'INFO',
        
        [Parameter(Mandatory=$false)]
        [string]$LogPath = "$env:TEMP\PowerShell_$(Get-Date -Format 'yyyyMMdd').log"
    )
    
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $logEntry = "[$timestamp] [$Level] $Message"
    
    # Write to file
    try {
        Add-Content -Path $LogPath -Value $logEntry -ErrorAction Stop
    }
    catch {
        Write-Warning "Failed to write to log file: $_"
    }
    
    # Write to console with color
    $color = switch ($Level) {
        'INFO'    { 'White' }
        'WARNING' { 'Yellow' }
        'ERROR'   { 'Red' }
        'DEBUG'   { 'Gray' }
    }
    
    Write-Host $logEntry -ForegroundColor $color
}

# Usage examples
Write-Log -Message "Script started" -Level INFO
Write-Log -Message "Processing user data" -Level DEBUG
Write-Log -Message "Disk space low" -Level WARNING
Write-Log -Message "Failed to connect to server" -Level ERROR

# config.json file content:
<#
{
    "General": {
        "LogPath": "C:\Logs",
        "MaxRetries": 3,
        "Timeout": 30
    },
    "Email": {
        "SmtpServer": "smtp.company.com",
        "From": "[email protected]",
        "To": ["[email protected]", "[email protected]"]
    },
    "Servers": [
        "Server01",
        "Server02",
        "Server03"
    ]
}
#>

# Load configuration
function Get-ScriptConfig {
    param(
        [string]$ConfigPath = "$PSScriptRoot\config.json"
    )
    
    if (-not (Test-Path $ConfigPath)) {
        throw "Configuration file not found: $ConfigPath"
    }
    
    try {
        $config = Get-Content -Path $ConfigPath -Raw | ConvertFrom-Json
        return $config
    }
    catch {
        throw "Failed to load configuration: $_"
    }
}

# Use configuration
$config = Get-ScriptConfig
$logPath = $config.General.LogPath
$servers = $config.Servers
$smtpServer = $config.Email.SmtpServer

Write-Host "Log Path: $logPath"
Write-Host "Servers: $($servers -join ', ')"
Write-Host "SMTP Server: $smtpServer"

function Invoke-SafeOperation {
    param(
        [string]$ComputerName,
        [int]$MaxRetries = 3,
        [int]$RetryDelaySeconds = 5
    )
    
    $attempt = 0
    $success = $false
    
    while (-not $success -and $attempt -lt $MaxRetries) {
        $attempt++
        
        try {
            Write-Log "Attempt $attempt of $MaxRetries for $ComputerName" -Level INFO
            
            # Test connectivity first
            if (-not (Test-Connection -ComputerName $ComputerName -Count 1 -Quiet)) {
                throw "Computer $ComputerName is not reachable"
            }
            
            # Perform operation
            $result = Invoke-Command -ComputerName $ComputerName -ScriptBlock {
                Get-Service | Where-Object {$_.Status -eq 'Running'}
            } -ErrorAction Stop
            
            Write-Log "Successfully retrieved services from $ComputerName" -Level INFO
            $success = $true
            return $result
        }
        catch [System.Management.Automation.Remoting.PSRemotingTransportException] {
            Write-Log "Remoting error for $ComputerName : $_" -Level WARNING
            
            if ($attempt -lt $MaxRetries) {
                Write-Log "Retrying in $RetryDelaySeconds seconds..." -Level INFO
                Start-Sleep -Seconds $RetryDelaySeconds
            }
        }
        catch [System.Net.NetworkInformation.PingException] {
            Write-Log "Network error for $ComputerName : $_" -Level ERROR
            break  # Don't retry network errors
        }
        catch {
            Write-Log "Unexpected error for $ComputerName : $_" -Level ERROR
            Write-Log "Error Type: $($_.Exception.GetType().FullName)" -Level DEBUG
            
            if ($attempt -lt $MaxRetries) {
                Start-Sleep -Seconds $RetryDelaySeconds
            }
        }
    }
    
    if (-not $success) {
        Write-Log "Failed to complete operation for $ComputerName after $MaxRetries attempts" -Level ERROR
        return $null
    }
}

# Usage
$result = Invoke-SafeOperation -ComputerName "Server01" -MaxRetries 3

<#
.SYNOPSIS
    Comprehensive server health check with email reporting.

.DESCRIPTION
    Checks multiple servers for disk space, CPU, memory, services, and event log errors.
    Generates HTML report and sends email if issues are found.

.PARAMETER ComputerName
    Array of computer names to check.

.PARAMETER DiskSpaceThreshold
    Percentage of free disk space that triggers a warning (default: 20).

.PARAMETER SendEmail
    Switch to enable email notifications.

.EXAMPLE
    .\ServerHealthCheck.ps1 -ComputerName "Server01","Server02" -SendEmail
#>

[CmdletBinding()]
param(
    [Parameter(Mandatory=$true)]
    [string[]]$ComputerName,
    
    [Parameter(Mandatory=$false)]
    [int]$DiskSpaceThreshold = 20,
    
    [Parameter(Mandatory=$false)]
    [switch]$SendEmail,
    
    [Parameter(Mandatory=$false)]
    [string]$SmtpServer = "smtp.company.com",
    
    [Parameter(Mandatory=$false)]
    [string]$EmailFrom = "[email protected]",
    
    [Parameter(Mandatory=$false)]
    [string[]]$EmailTo = @("[email protected]")
)

# Initialize
$ErrorActionPreference = 'Continue'
$reportPath = "$PSScriptRoot\Reports\HealthCheck_$(Get-Date -Format 'yyyyMMdd_HHmmss').html"
$results = @()

# Ensure report directory exists
$reportDir = Split-Path $reportPath -Parent
if (-not (Test-Path $reportDir)) {
    New-Item -Path $reportDir -ItemType Directory -Force | Out-Null
}

Write-Host "Starting health check for $($ComputerName.Count) servers..." -ForegroundColor Cyan

foreach ($computer in $ComputerName) {
    Write-Host "`nChecking $computer..." -ForegroundColor Yellow
    
    $serverHealth = [PSCustomObject]@{
        ServerName = $computer
        Status = 'Unknown'
        Uptime = $null
        CPUUsage = $null
        MemoryUsedPercent = $null
        DiskInfo = @()
        CriticalServices = @()
        RecentErrors = 0
        Issues = @()
    }
    
    try {
        # Test connectivity
        if (-not (Test-Connection -ComputerName $computer -Count 1 -Quiet)) {
            throw "Server is not reachable"
        }
        
        # Create CIM session
        $session = New-CimSession -ComputerName $computer -ErrorAction Stop
        
        # Get OS information
        $os = Get-CimInstance -ClassName Win32_OperatingSystem -CimSession $session
        $lastBoot = $os.LastBootUpTime
        $uptime = (Get-Date) - $lastBoot
        $serverHealth.Uptime = "$($uptime.Days)d $($uptime.Hours)h $($uptime.Minutes)m"
        
        # Get CPU usage (average over 5 seconds)
        $cpu = Get-CimInstance -ClassName Win32_Processor -CimSession $session
        $serverHealth.CPUUsage = [math]::Round($cpu.LoadPercentage, 2)
        
        if ($serverHealth.CPUUsage -gt 80) {
            $serverHealth.Issues += "High CPU usage: $($serverHealth.CPUUsage)%"
        }
        
        # Get memory usage
        $totalMemory = $os.TotalVisibleMemorySize
        $freeMemory = $os.FreePhysicalMemory
        $usedMemory = $totalMemory - $freeMemory
        $memoryPercent = [math]::Round(($usedMemory / $totalMemory) * 100, 2)
        $serverHealth.MemoryUsedPercent = $memoryPercent
        
        if ($memoryPercent -gt 90) {
            $serverHealth.Issues += "High memory usage: $memoryPercent%"
        }
        
        # Get disk space
        $disks = Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DriveType=3" -CimSession $session
        
        foreach ($disk in $disks) {
            $freePercent = [math]::Round(($disk.FreeSpace / $disk.Size) * 100, 2)
            $diskInfo = [PSCustomObject]@{
                Drive = $disk.DeviceID
                SizeGB = [math]::Round($disk.Size / 1GB, 2)
                FreeGB = [math]::Round($disk.FreeSpace / 1GB, 2)
                FreePercent = $freePercent
            }
            
            $serverHealth.DiskInfo += $diskInfo
            
            if ($freePercent -lt $DiskSpaceThreshold) {
                $serverHealth.Issues += "Low disk space on $($disk.DeviceID): $freePercent% free"
            }
        }
        
        # Check critical services
        $criticalServices = @('W32Time', 'Winmgmt', 'RpcSs', 'Dhcp', 'Dnscache')
        $services = Get-CimInstance -ClassName Win32_Service -CimSession $session |
                    Where-Object {$_.Name -in $criticalServices}
        
        foreach ($service in $services) {
            if ($service.State -ne 'Running') {
                $serverHealth.CriticalServices += "$($service.DisplayName) is $($service.State)"
                $serverHealth.Issues += "Service $($service.DisplayName) is not running"
            }
        }
        
        # Check recent errors in System event log (last 24 hours)
        $yesterday = (Get-Date).AddDays(-1)
        $errors = Get-WinEvent -ComputerName $computer -FilterHashtable @{
            LogName = 'System'
            Level = 2  # Error
            StartTime = $yesterday
        } -ErrorAction SilentlyContinue
        
        $serverHealth.RecentErrors = $errors.Count
        
        if ($errors.Count -gt 10) {
            $serverHealth.Issues += "$($errors.Count) errors in System log (last 24h)"
        }
        
        # Set overall status
        $serverHealth.Status = if ($serverHealth.Issues.Count -eq 0) { 'Healthy' } else { 'Warning' }
        
        # Clean up
        Remove-CimSession -CimSession $session
        
        Write-Host "  Status: $($serverHealth.Status)" -ForegroundColor $(if($serverHealth.Status -eq 'Healthy'){'Green'}else{'Yellow'})
    }
    catch {
        $serverHealth.Status = 'Error'
        $serverHealth.Issues += "Failed to retrieve data: $_"
        Write-Host "  Status: Error - $_" -ForegroundColor Red
    }
    
    $results += $serverHealth
}

# Generate HTML Report
$htmlHead = @"

"@

$htmlBody = "
Server Health Check Report
"
$htmlBody += "
Generated: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')
"

foreach ($server in $results) {
    $statusClass = $server.Status.ToLower()
    
    $htmlBody += "
$($server.ServerName) - $($server.Status)
"
    $htmlBody += ""
    $htmlBody += ""
    $htmlBody += ""
    $htmlBody += ""
    $htmlBody += ""
    $htmlBody += ""
    $htmlBody += "
Metric
Value
Uptime
$($server.Uptime)
CPU Usage
$($server.CPUUsage)%
Memory Used
$($server.MemoryUsedPercent)%
Recent Errors
$($server.RecentErrors)
"
    
    if ($server.DiskInfo.Count -gt 0) {
        $htmlBody += "
Disk Space
"
        $htmlBody += ""
        foreach ($disk in $server.DiskInfo) {
            $htmlBody += ""
        }
        $htmlBody += "
Drive
Size (GB)
Free (GB)
Free %
$($disk.Drive)
$($disk.SizeGB)
$($disk.FreeGB)
$($disk.FreePercent)%
"
    }
    
    if ($server.Issues.Count -gt 0) {
        $htmlBody += "
Issues Found:
"
        foreach ($issue in $server.Issues) {
            $htmlBody += "
$issue
"
        }
        $htmlBody += "
"
    }
}

$htmlReport = $htmlHead + $htmlBody

# Save report
$htmlReport | Out-File -FilePath $reportPath -Encoding UTF8
Write-Host "`nReport saved to: $reportPath" -ForegroundColor Green

# Send email if requested and issues found
$issueCount = ($results | Where-Object {$_.Issues.Count -gt 0}).Count

if ($SendEmail -and $issueCount -gt 0) {
    try {
        $emailParams = @{
            SmtpServer = $SmtpServer
            From = $EmailFrom
            To = $EmailTo
            Subject = "Server Health Check Alert - $issueCount server(s) with issues"
            Body = $htmlReport
            BodyAsHtml = $true
        }
        
        Send-MailMessage @emailParams
        Write-Host "Email notification sent to $($EmailTo -join ', ')" -ForegroundColor Green
    }
    catch {
        Write-Warning "Failed to send email: $_"
    }
}

Write-Host "`nHealth check complete!" -ForegroundColor Cyan
Write-Host "Servers checked: $($results.Count)" -ForegroundColor White
Write-Host "Healthy: $(($results | Where-Object {$_.Status -eq 'Healthy'}).Count)" -ForegroundColor Green
Write-Host "Issues: $issueCount" -ForegroundColor $(if($issueCount -gt 0){'Yellow'}else{'Green'})

<#
.SYNOPSIS
    Automated backup system with rotation and email notifications.

.DESCRIPTION
    Backs up specified folders, maintains retention policy, and sends email reports.
    Supports compression, verification, and automatic cleanup of old backups.
#>

[CmdletBinding()]
param(
    [Parameter(Mandatory=$true)]
    [string[]]$SourcePaths,
    
    [Parameter(Mandatory=$true)]
    [string]$BackupDestination,
    
    [Parameter(Mandatory=$false)]
    [int]$RetentionDays = 30,
    
    [Parameter(Mandatory=$false)]
    [switch]$Compress,
    
    [Parameter(Mandatory=$false)]
    [switch]$SendEmail,
    
    [Parameter(Mandatory=$false)]
    [string]$SmtpServer = "smtp.company.com",
    
    [Parameter(Mandatory=$false)]
    [string]$EmailFrom = "[email protected]",
    
    [Parameter(Mandatory=$false)]
    [string[]]$EmailTo = @("[email protected]")
)

# Initialize logging
$logPath = "$BackupDestination\Logs\Backup_$(Get-Date -Format 'yyyyMMdd_HHmmss').log"
$logDir = Split-Path $logPath -Parent

if (-not (Test-Path $logDir)) {
    New-Item -Path $logDir -ItemType Directory -Force | Out-Null
}

function Write-BackupLog {
    param([string]$Message, [string]$Level = 'INFO')
    
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $logEntry = "[$timestamp] [$Level] $Message"
    
    Add-Content -Path $logPath -Value $logEntry
    
    $color = switch ($Level) {
        'INFO' { 'White' }
        'SUCCESS' { 'Green' }
        'WARNING' { 'Yellow' }
        'ERROR' { 'Red' }
    }
    
    Write-Host $logEntry -ForegroundColor $color
}

# Start backup process
Write-BackupLog "=== Backup Process Started ===" -Level INFO
Write-BackupLog "Source Paths: $($SourcePaths -join ', ')" -Level INFO
Write-BackupLog "Destination: $BackupDestination" -Level INFO
Write-BackupLog "Retention: $RetentionDays days" -Level INFO

$backupResults = @()
$totalSize = 0
$successCount = 0
$failCount = 0

# Create backup destination if it doesn't exist
if (-not (Test-Path $BackupDestination)) {
    New-Item -Path $BackupDestination -ItemType Directory -Force | Out-Null
    Write-BackupLog "Created backup destination: $BackupDestination" -Level INFO
}

# Process each source path
foreach ($sourcePath in $SourcePaths) {
    $sourceName = Split-Path $sourcePath -Leaf
    $timestamp = Get-Date -Format 'yyyyMMdd_HHmmss'
    $backupName = "$sourceName`_$timestamp"
    $destinationPath = Join-Path $BackupDestination $backupName
    
    Write-BackupLog "Processing: $sourcePath" -Level INFO
    
    $result = [PSCustomObject]@{
        SourcePath = $sourcePath
        BackupName = $backupName
        DestinationPath = $destinationPath
        Status = 'Unknown'
        SizeMB = 0
        Duration = $null
        ErrorMessage = $null
    }
    
    try {
        # Validate source path
        if (-not (Test-Path $sourcePath)) {
            throw "Source path does not exist: $sourcePath"
        }
        
        $startTime = Get-Date
        
        if ($Compress) {
            # Compress backup
            $zipPath = "$destinationPath.zip"
            Write-BackupLog "Creating compressed backup: $zipPath" -Level INFO
            
            Compress-Archive -Path $sourcePath -DestinationPath $zipPath -CompressionLevel Optimal -Force
            
            $backupSize = (Get-Item $zipPath).Length
            $result.DestinationPath = $zipPath
        }
        else {
            # Copy without compression
            Write-BackupLog "Copying to: $destinationPath" -Level INFO
            
            Copy-Item -Path $sourcePath -Destination $destinationPath -Recurse -Force
            
            $backupSize = (Get-ChildItem -Path $destinationPath -Recurse | 
                          Measure-Object -Property Length -Sum).Sum
        }
        
        $endTime = Get-Date
        $duration = $endTime - $startTime
        
        $result.Status = 'Success'
        $result.SizeMB = [math]::Round($backupSize / 1MB, 2)
        $result.Duration = "$($duration.Minutes)m $($duration.Seconds)s"
        
        $totalSize += $result.SizeMB
        $successCount++
        
        Write-BackupLog "Backup completed: $backupName ($($result.SizeMB) MB in $($result.Duration))" -Level SUCCESS
    }
    catch {
        $result.Status = 'Failed'
        $result.ErrorMessage = $_.Exception.Message
        $failCount++
        
        Write-BackupLog "Backup failed for $sourcePath : $_" -Level ERROR
    }
    
    $backupResults += $result
}

# Cleanup old backups based on retention policy
Write-BackupLog "`n=== Cleaning up old backups ===" -Level INFO

try {
    $cutoffDate = (Get-Date).AddDays(-$RetentionDays)
    $oldBackups = Get-ChildItem -Path $BackupDestination -Recurse | 
                  Where-Object {$_.LastWriteTime -lt $cutoffDate}
    
    if ($oldBackups) {
        Write-BackupLog "Found $($oldBackups.Count) old backup(s) to remove" -Level INFO
        
        foreach ($oldBackup in $oldBackups) {
            try {
                Remove-Item -Path $oldBackup.FullName -Recurse -Force
                Write-BackupLog "Removed old backup: $($oldBackup.Name)" -Level INFO
            }
            catch {
                Write-BackupLog "Failed to remove $($oldBackup.Name): $_" -Level WARNING
            }
        }
    }
    else {
        Write-BackupLog "No old backups to remove" -Level INFO
    }
}
catch {
    Write-BackupLog "Error during cleanup: $_" -Level ERROR
}

# Generate summary
Write-BackupLog "`n=== Backup Summary ===" -Level INFO
Write-BackupLog "Total backups attempted: $($backupResults.Count)" -Level INFO
Write-BackupLog "Successful: $successCount" -Level SUCCESS
Write-BackupLog "Failed: $failCount" -Level $(if($failCount -gt 0){'ERROR'}else{'INFO'})
Write-BackupLog "Total size: $([math]::Round($totalSize / 1024, 2)) GB" -Level INFO

# Generate HTML report
$htmlReport = @"





Backup Report
Date: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')
Total Backups: $($backupResults.Count)
Successful: $successCount
Failed: $failCount
Total Size: $([math]::Round($totalSize / 1024, 2)) GB

Backup Details

"@

foreach ($result in $backupResults) {
    $statusClass = if ($result.Status -eq 'Success') { 'success' } else { 'failed' }
    $htmlReport += @"

"@
}

$htmlReport += "


    
Source Path
    
Backup Name
    
Status
    
Size (MB)
    
Duration

    
$($result.SourcePath)
    
$($result.BackupName)
    
$($result.Status)
    
$($result.SizeMB)
    
$($result.Duration)
"

# Save HTML report
$reportPath = "$BackupDestination\Logs\BackupReport_$(Get-Date -Format 'yyyyMMdd_HHmmss').html"
$htmlReport | Out-File -FilePath $reportPath -Encoding UTF8
Write-BackupLog "Report saved to: $reportPath" -Level INFO

# Send email if requested
if ($SendEmail) {
    try {
        $subject = if ($failCount -gt 0) {
            "Backup Report - $failCount Failed"
        } else {
            "Backup Report - All Successful"
        }
        
        Send-MailMessage -SmtpServer $SmtpServer -From $EmailFrom -To $EmailTo `
                         -Subject $subject -Body $htmlReport -BodyAsHtml
        
        Write-BackupLog "Email report sent to $($EmailTo -join ', ')" -Level SUCCESS
    }
    catch {
        Write-BackupLog "Failed to send email: $_" -Level ERROR
    }
}

Write-BackupLog "`n=== Backup Process Completed ===" -Level INFO

<#
.SYNOPSIS
    Bulk user account creation from CSV file with error handling and reporting.

.DESCRIPTION
    Creates Active Directory user accounts from a CSV file with the following columns:
    FirstName, LastName, Username, Email, Department, Title, Manager

.PARAMETER CsvPath
    Path to the CSV file containing user information.

.PARAMETER OU
    Organizational Unit where users will be created.

.EXAMPLE
    .\BulkUserCreation.ps1 -CsvPath "C:\Users.csv" -OU "OU=Users,DC=company,DC=com"
#>

[CmdletBinding()]
param(
    [Parameter(Mandatory=$true)]
    [ValidateScript({Test-Path $_})]
    [string]$CsvPath,
    
    [Parameter(Mandatory=$true)]
    [string]$OU,
    
    [Parameter(Mandatory=$false)]
    [string]$DefaultPassword = "P@ssw0rd123!",
    
    [Parameter(Mandatory=$false)]
    [switch]$SendWelcomeEmail
)

# Import Active Directory module
try {
    Import-Module ActiveDirectory -ErrorAction Stop
}
catch {
    Write-Error "Failed to import Active Directory module: $_"
    exit 1
}

# Initialize
$logPath = "$PSScriptRoot\Logs\UserCreation_$(Get-Date -Format 'yyyyMMdd_HHmmss').log"
$logDir = Split-Path $logPath -Parent

if (-not (Test-Path $logDir)) {
    New-Item -Path $logDir -ItemType Directory -Force | Out-Null
}

function Write-UserLog {
    param([string]$Message, [string]$Level = 'INFO')
    
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $logEntry = "[$timestamp] [$Level] $Message"
    
    Add-Content -Path $logPath -Value $logEntry
    Write-Host $logEntry -ForegroundColor $(
        switch($Level) {
            'SUCCESS' {'Green'}
            'WARNING' {'Yellow'}
            'ERROR' {'Red'}
            default {'White'}
        }
    )
}

Write-UserLog "=== Bulk User Creation Started ===" -Level INFO
Write-UserLog "CSV File: $CsvPath" -Level INFO
Write-UserLog "Target OU: $OU" -Level INFO

# Import CSV
try {
    $users = Import-Csv -Path $CsvPath
    Write-UserLog "Loaded $($users.Count) users from CSV" -Level INFO
}
catch {
    Write-UserLog "Failed to import CSV: $_" -Level ERROR
    exit 1
}

# Validate OU exists
try {
    Get-ADOrganizationalUnit -Identity $OU -ErrorAction Stop | Out-Null
}
catch {
    Write-UserLog "OU does not exist: $OU" -Level ERROR
    exit 1
}

$results = @()
$successCount = 0
$failCount = 0
$securePassword = ConvertTo-SecureString $DefaultPassword -AsPlainText -Force

foreach ($user in $users) {
    $username = $user.Username
    Write-UserLog "`nProcessing user: $username" -Level INFO
    
    $result = [PSCustomObject]@{
        Username = $username
        FullName = "$($user.FirstName) $($user.LastName)"
        Email = $user.Email
        Status = 'Unknown'
        Message = ''
    }
    
    try {
        # Check if user already exists
        $existingUser = Get-ADUser -Filter "SamAccountName -eq '$username'" -ErrorAction SilentlyContinue
        
        if ($existingUser) {
            throw "User already exists: $username"
        }
        
        # Validate required fields
        if ([string]::IsNullOrWhiteSpace($user.FirstName) -or 
            [string]::IsNullOrWhiteSpace($user.LastName)) {
            throw "First name and last name are required"
        }
        
        # Create user parameters
        $userParams = @{
            SamAccountName = $username
            UserPrincipalName = "[email protected]"
            Name = "$($user.FirstName) $($user.LastName)"
            GivenName = $user.FirstName
            Surname = $user.LastName
            DisplayName = "$($user.FirstName) $($user.LastName)"
            EmailAddress = $user.Email
            Department = $user.Department
            Title = $user.Title
            Path = $OU
            AccountPassword = $securePassword
            Enabled = $true
            ChangePasswordAtLogon = $true
        }
        
        # Add manager if specified
        if (-not [string]::IsNullOrWhiteSpace($user.Manager)) {
            $manager = Get-ADUser -Filter "SamAccountName -eq '$($user.Manager)'" -ErrorAction SilentlyContinue
            if ($manager) {
                $userParams['Manager'] = $manager.DistinguishedName
            }
        }
        
        # Create the user
        New-ADUser @userParams -ErrorAction Stop
        
        $result.Status = 'Success'
        $result.Message = 'User created successfully'
        $successCount++
        
        Write-UserLog "Successfully created user: $username" -Level SUCCESS
        
        # Send welcome email if requested
        if ($SendWelcomeEmail -and -not [string]::IsNullOrWhiteSpace($user.Email)) {
            try {
                $emailBody = @"
Welcome to the company, $($user.FirstName)!

Your account has been created with the following details:
Username: $username
Email: $($user.Email)
Temporary Password: $DefaultPassword

Please change your password at first login.

Best regards,
IT Department
"@
                
                Send-MailMessage -SmtpServer "smtp.company.com" `
                                 -From "[email protected]" `
                                 -To $user.Email `
                                 -Subject "Welcome - Your Account Has Been Created" `
                                 -Body $emailBody
                
                Write-UserLog "Welcome email sent to $($user.Email)" -Level INFO
            }
            catch {
                Write-UserLog "Failed to send welcome email: $_" -Level WARNING
            }
        }
    }
    catch {
        $result.Status = 'Failed'
        $result.Message = $_.Exception.Message
        $failCount++
        
        Write-UserLog "Failed to create user $username : $_" -Level ERROR
    }
    
    $results += $result
}

# Generate summary report
Write-UserLog "`n=== User Creation Summary ===" -Level INFO
Write-UserLog "Total users processed: $($results.Count)" -Level INFO
Write-UserLog "Successful: $successCount" -Level SUCCESS
Write-UserLog "Failed: $failCount" -Level $(if($failCount -gt 0){'ERROR'}else{'INFO'})

# Export results to CSV
$resultsPath = "$PSScriptRoot\Logs\UserCreationResults_$(Get-Date -Format 'yyyyMMdd_HHmmss').csv"
$results | Export-Csv -Path $resultsPath -NoTypeInformation
Write-UserLog "Results exported to: $resultsPath" -Level INFO

Write-UserLog "`n=== Bulk User Creation Completed ===" -Level INFO

# WRONG - Never do this!
$password = "MyPassword123"
$username = "admin"

# RIGHT - Use Get-Credential
$credential = Get-Credential -Message "Enter your credentials"

# RIGHT - Store encrypted credentials
$credential = Get-Credential
$credential | Export-Clixml -Path "$env:USERPROFILE\cred.xml"

# Load encrypted credentials
$credential = Import-Clixml -Path "$env:USERPROFILE\cred.xml"

# Use with remoting
Invoke-Command -ComputerName Server01 -Credential $credential -ScriptBlock {
    Get-Service
}

# Secure string for passwords
$securePassword = Read-Host "Enter password" -AsSecureString
$BSTR = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($securePassword)
$plainPassword = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto($BSTR)

# Install Pester if needed
# Install-Module -Name Pester -Force -SkipPublisherCheck

# Sample function to test
function Get-DiskSpaceInfo {
    param([string]$ComputerName = $env:COMPUTERNAME)
    
    Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DriveType=3" -ComputerName $ComputerName |
        Select-Object DeviceID, 
            @{Name='SizeGB';Expression={[math]::Round($_.Size/1GB,2)}},
            @{Name='FreeGB';Expression={[math]::Round($_.FreeSpace/1GB,2)}}
}

# Pester test file: Get-DiskSpaceInfo.Tests.ps1
Describe "Get-DiskSpaceInfo" {
    Context "Parameter Validation" {
        It "Should accept ComputerName parameter" {
            {Get-DiskSpaceInfo -ComputerName "localhost"} | Should -Not -Throw
        }
        
        It "Should use default computer name if not specified" {
            $result = Get-DiskSpaceInfo
            $result | Should -Not -BeNullOrEmpty
        }
    }
    
    Context "Output Validation" {
        It "Should return objects with required properties" {
            $result = Get-DiskSpaceInfo
            $result[0].PSObject.Properties.Name | Should -Contain 'DeviceID'
            $result[0].PSObject.Properties.Name | Should -Contain 'SizeGB'
            $result[0].PSObject.Properties.Name | Should -Contain 'FreeGB'
        }
        
        It "Should return numeric values for size properties" {
            $result = Get-DiskSpaceInfo
            $result[0].SizeGB | Should -BeOfType [double]
            $result[0].FreeGB | Should -BeOfType [double]
        }
    }
}

# Run tests
Invoke-Pester -Path "Get-DiskSpaceInfo.Tests.ps1"

# Navigation
Get-Location                    # Current directory (pwd)
Set-Location C:\Path           # Change directory (cd)
Set-Location ..                 # Go up one level
Push-Location C:\Path          # Save and change location
Pop-Location                    # Return to saved location

# Listing
Get-ChildItem                   # List items (ls, dir)
Get-ChildItem -Recurse          # List recursively
Get-ChildItem -Force            # Include hidden files
Get-ChildItem *.txt             # Filter by extension

# Create
New-Item -Path "file.txt" -ItemType File
New-Item -Path "folder" -ItemType Directory
New-Item -Path "file.txt" -ItemType File -Value "content"

# Copy
Copy-Item -Path "source.txt" -Destination "dest.txt"
Copy-Item -Path "folder" -Destination "dest" -Recurse

# Move
Move-Item -Path "source.txt" -Destination "dest.txt"

# Delete
Remove-Item -Path "file.txt"
Remove-Item -Path "folder" -Recurse -Force

# Rename
Rename-Item -Path "old.txt" -NewName "new.txt"

# Test existence
Test-Path "C:\file.txt"

# Declaration
$variable = "value"
$number = 42
$array = @(1, 2, 3, 4, 5)
$hashtable = @{Key1 = "Value1"; Key2 = "Value2"}

# Special Variables
$PSVersionTable                 # PowerShell version
$env:USERNAME                   # Environment variables
$env:COMPUTERNAME
$env:PATH
$_                              # Current pipeline object
$args                           # Script arguments
$PSScriptRoot                   # Script directory
$PWD                            # Current directory

# Type Casting
[int]$number = "42"
[string]$text = 123
[datetime]$date = "2024-01-01"
[array]$list = 1,2,3

# Arrays
$array = @(1, 2, 3, 4, 5)
$array[0]                       # First element
$array[-1]                      # Last element
$array.Count                    # Number of elements
$array += 6                     # Add element
$array -contains 3              # Check if contains

# Hashtables
$hash = @{
    Name = "John"
    Age = 30
    City = "New York"
}
$hash["Name"]                   # Access value
$hash.Name                      # Dot notation
$hash.Keys                      # All keys
$hash.Values                    # All values
$hash.Add("Email", "[email protected]")
$hash.Remove("Age")

# Comparison (Case-Insensitive)
-eq                             # Equal
-ne                             # Not equal
-gt                             # Greater than
-ge                             # Greater than or equal
-lt                             # Less than
-le                             # Less than or equal
-like                           # Wildcard match
-match                          # Regex match
-contains                       # Collection contains
-in                             # Item in collection

# Case-Sensitive Versions
-ceq, -cne, -cgt, -cge, -clt, -cle, -clike, -cmatch

# Logical Operators
-and                            # Logical AND
-or                             # Logical OR
-not                            # Logical NOT
!                               # Logical NOT (alternative)
-xor                            # Exclusive OR

# String Operators
-replace                        # Replace text
-split                          # Split string
-join                           # Join array elements

# If/Else
if ($condition) {
    # code
} elseif ($condition2) {
    # code
} else {
    # code
}

# Switch
switch ($value) {
    1 { "One" }
    2 { "Two" }
    default { "Other" }
}

# Switch with wildcard
switch -Wildcard ($text) {
    "*.txt" { "Text file" }
    "*.log" { "Log file" }
    default { "Unknown" }
}

# ForEach
foreach ($item in $collection) {
    Write-Host $item
}

# ForEach-Object (Pipeline)
$collection | ForEach-Object {
    Write-Host $_
}

# For
for ($i = 0; $i -lt 10; $i++) {
    Write-Host $i
}

# While
while ($condition) {
    # code
}

# Do-While
do {
    # code
} while ($condition)

# Do-Until
do {
    # code
} until ($condition)

# Break & Continue
break                           # Exit loop
continue                        # Skip to next iteration

# Basic Function
function Get-Something {
    param($Parameter1, $Parameter2)
    # code
    return $result
}

# Advanced Function
function Get-Something {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$Name,
        
        [Parameter(Mandatory=$false)]
        [int]$Count = 10,
        
        [ValidateSet("Option1", "Option2")]
        [string]$Option
    )
    
    begin { }
    process { }
    end { }
}

# Call Function
Get-Something -Name "Test" -Count 5