PowerShell Script Prompt for Windows Automation

```powershell
<#
.SYNOPSIS
    A versatile PowerShell automation script demonstrating common tasks:
    - Validates parameters
    - Creates and cleans up directories
    - Backs up files based on extension
    - Logs script activities and errors
    - Optionally stops specified running processes

.DESCRIPTION
    This script accepts parameters to specify:
    - The target directory to scan
    - File extension filter for backup
    - Backup destination directory
    - An optional list of process names to stop
    
    It performs the following steps:
    1. Validates input parameters and environment.
    2. Creates a backup directory if it doesn't exist.
    3. Copies files matching the given extension from the target directory (recursively) to the backup directory.
    4. Deletes files older than 30 days in the backup directory.
    5. Optionally stops specified processes, handling errors if the process does not exist or cannot be stopped.
    6. Logs all actions and errors to a timestamped log file in the script directory.

.NOTES
    - Designed for Windows PowerShell 5.1+ or PowerShell Core.
    - Handles common edge cases: missing directories, access denied, no matching files, no processes found.
    - Includes error handling and verbose output.

.EXAMPLE
    .\AutomationSample.ps1 -TargetDir "C:\Data" -FileExt ".txt" -BackupDir "D:\Backup" -StopProcesses "notepad","calc"
#>

[CmdletBinding()]
param(
    [Parameter(Mandatory=$true)]
    [ValidateScript({ Test-Path $_ -PathType 'Container' })]
    [string]$TargetDir,

    [Parameter(Mandatory=$true)]
    [ValidatePattern('^\.\w+$')] # E.g. ".txt", ".log"
    [string]$FileExt,

    [Parameter(Mandatory=$true)]
    [string]$BackupDir,

    [Parameter(Mandatory=$false)]
    [string[]]$StopProcesses
)

function Write-Log {
    param(
        [string]$Message,
        [string]$Level = "INFO"
    )
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $logEntry = "$timestamp [$Level] $Message"
    Write-Output $logEntry
    Add-Content -Path $Global:LogFile -Value $logEntry
}

try {
    # Initialize log file
    $Global:LogFile = Join-Path -Path $PSScriptRoot -ChildPath ("AutomationSample_{0}.log" -f (Get-Date -Format "yyyyMMdd_HHmmss"))
    Write-Log "Script started."

    # Normalize paths
    $TargetDir = (Get-Item -LiteralPath $TargetDir).FullName
    $BackupDir = Resolve-Path -Path $BackupDir -ErrorAction SilentlyContinue
    if (-not $BackupDir) {
        # Create backup directory if it does not exist
        Write-Log "Backup directory '$BackupDir' does not exist. Attempting to create."
        try {
            New-Item -Path $BackupDir -ItemType Directory -Force -ErrorAction Stop | Out-Null
            Write-Log "Backup directory created."
        } catch {
            # If $BackupDir was null, create from path string
            try {
                New-Item -Path $(Split-Path $BackupDir -Parent) -ItemType Directory -Force -ErrorAction Stop | Out-Null
                New-Item -Path $BackupDir -ItemType Directory -Force -ErrorAction Stop | Out-Null
                Write-Log "Backup directory created."
            } catch {
                throw "Failed to create backup directory '$BackupDir'. $_"
            }
        }
        $BackupDir = Resolve-Path -Path $BackupDir
    } else {
        $BackupDir = $BackupDir.Path
        Write-Log "Backup directory found at '$BackupDir'."
    }

    # Log input summary
    Write-Log "Target directory: $TargetDir"
    Write-Log "File extension filter: $FileExt"
    Write-Log "Backup directory: $BackupDir"
    if ($StopProcesses) {
        Write-Log "Processes to stop: $($StopProcesses -join ', ')"
    } else {
        Write-Log "No processes specified to stop."
    }

    # Retrieve files matching extension recursively
    Write-Log "Searching for files with extension '$FileExt' in '$TargetDir'."
    $files = Get-ChildItem -Path $TargetDir -Recurse -File -ErrorAction Stop |
             Where-Object { $_.Extension -ieq $FileExt }
    if (-not $files) {
        Write-Log "No files with extension '$FileExt' found in '$TargetDir'." "WARN"
    } else {
        Write-Log "Found $($files.Count) file(s) to backup."
    }

    # Copy files to backup directory preserving folder structure relative to TargetDir
    foreach ($file in $files) {
        # Determine relative path
        $relativePath = $file.DirectoryName.Substring($TargetDir.Length).TrimStart('\','/')
        $destinationDir = Join-Path -Path $BackupDir -ChildPath $relativePath
        if (-not (Test-Path $destinationDir)) {
            New-Item -Path $destinationDir -ItemType Directory -Force -ErrorAction Stop | Out-Null
        }
        $destinationFile = Join-Path -Path $destinationDir -ChildPath $file.Name
        try {
            Copy-Item -Path $file.FullName -Destination $destinationFile -Force -ErrorAction Stop
            Write-Log "Copied '$($file.FullName)' to '$destinationFile'."
        } catch {
            Write-Log "Failed to copy '$($file.FullName)': $_" "ERROR"
        }
    }

    # Clean up: Delete files older than 30 days in backup directory
    Write-Log "Cleaning up files older than 30 days in backup directory."
    $thresholdDate = (Get-Date).AddDays(-30)
    $oldFiles = Get-ChildItem -Path $BackupDir -Recurse -File -ErrorAction SilentlyContinue | Where-Object { $_.LastWriteTime -lt $thresholdDate }
    foreach ($oldFile in $oldFiles) {
        try {
            Remove-Item -Path $oldFile.FullName -Force -ErrorAction Stop
            Write-Log "Deleted old backup file '$($oldFile.FullName)'."
        } catch {
            Write-Log "Failed to delete old backup file '$($oldFile.FullName)': $_" "ERROR"
        }
    }
    Write-Log "Cleanup complete."

    # Optionally stop processes
    if ($StopProcesses) {
        foreach ($procName in $StopProcesses) {
            try {
                $procs = Get-Process -Name $procName -ErrorAction SilentlyContinue
                if (-not $procs) {
                    Write-Log "Process '$procName' not found." "WARN"
                    continue
                }

                foreach ($proc