## Define the MSP name
[string]$Global:MSPName = "Emberkom"

## This section will define several global variables that can be used in scripts that source this one
[string]$Global:RootDirectory
[string]$Global:ScriptsDirectory
[string]$Global:OutputDirectory
[string]$Global:ToolsDirectory
[string]$Global:LogsDirectory
[string]$Global:LogFile

## Setup the MSP management directories
Function Setup-MSPDirectories {
    If ( Test-Path ${Env:ProgramData} ) { $Global:RootDirectory = "${Env:ProgramData}\${MSPName}" } Else { $Global:RootDirectory = "${Env:SystemDrive}\${MSPName}" }
    $Global:ScriptsDirectory = "${RootDirectory}\Scripts"
    $Global:OutputDirectory = "${RootDirectory}\Output"
    $Global:ToolsDirectory = "${RootDirectory}\Tools"
    $Global:LogsDirectory = "${RootDirectory}\Logs"

    ## Make sure all the management directories exist
    $RootDirectory, $ScriptsDirectory, $OutputDirectory, $ToolsDirectory, $LogsDirectory | ForEach-Object {
        If ( !(Test-Path $_) ) {
            Try { New-Item -Path $_ -ItemType Directory -Force -ErrorAction SilentlyContinue | Out-Null }
            Catch { Write-Output $_.Exception.Message }
        } 
    }
}

## Function to get a datestamp for right now in a long format
Function Get-LongDateTime {
    Return $(Get-Date -Format "yyyyMMddHHmmssffff")
}

## Setup the log file for messages generated when this script is run
Function Setup-LogFile {
    $LogFilePrefix = "ManagementScript"
    $LogFilePostfix = Get-LongDateTime
    $Global:LogFile = "${LogsDirectory}\${LogFilePrefix}_${LogFilePostfix}.log"
    
    ## Delete log files older than 30 days
    $LogFileAllowedAge = (Get-Date).AddDays(-30)
    Try {
        Get-ChildItem -Path "${LogsDirectory}\${LogFilePrefix}_*.*" -Filter '*.log' | `
        Where-Object {$_.LastWriteTime -lt $LogFileAllowedAge} | `
        Remove-Item -Force -ErrorAction SilentlyContinue | Out-Null
    }
    Catch { Write-Output $_.Exception.Message }
    
    Try { If ( !(Test-Path $LogFile) ) { New-Item -Path $LogFile -ItemType File -Force | Out-Null } }
    Catch { Write-Output $_.Exception.Message }
}

## Log a message to the log file
Function LogMsg {
    param([Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$Message)
    $Timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $LogEntry = "${Timestamp} - ${Message}"
    Add-Content -Path $Global:LogFile -Value $LogEntry
}

## Log an error to the log file
Function LogErr {
    param([Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$Message)
    $Timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $LogEntry = "${Timestamp} - Error: ${Message}"
    Add-Content -Path $Global:LogFile -Value $LogEntry
}

## Function to determine if the current user context is an Administrator
Function IsAdmin {
    If ( ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator) )
    { Return $true } Else { Return $false }
}

## Run a script from the live repo or from a local path
Function Run-Script {
    param(
        ## Parameters for live-ps scripts
        [Parameter(Mandatory=$false,ParameterSetName='live-ps')]
        [string]$Type='management-scripts',
        [Parameter(Mandatory=$true,ParameterSetName='live-ps')]
        [string]$LivePSScript,
        ## Parameters for local scripts
        [Parameter(Mandatory=$true,ParameterSetName='local')]
        [string]$Path,
        #### $NoWait will prevent waiting for the specified script to finish running
        [Parameter(Mandatory=$false,ParameterSetName='local')]
        [switch]$NoWait=$false,
        ## Parameters for all scripts
        [Parameter(Mandatory=$false,ParameterSetName='live-ps')]
        [Parameter(Mandatory=$false,ParameterSetName='local')]
        [string]$Arguments='null',
        #### $HaltIfRunning is a collection of app names which, if running, will prevent the script from running
        [Parameter(Mandatory=$false,ParameterSetName='live-ps')]
        [Parameter(Mandatory=$false,ParameterSetName='local')]
        [string[]]$HaltIfRunning='null',
        #### $ForceClose will forcefully close all apps specified in $HaltIfRunning
        [Parameter(Mandatory=$false,ParameterSetName='live-ps')]
        [Parameter(Mandatory=$false,ParameterSetName='local')]
        [switch]$ForceClose=$false
    )
    If ( $Arguments -eq "null" ) { $Arguments = $null }
    If ( $HaltIfRunning -eq "null" ) { $HaltIfRunning = $null }
    If ( $LivePSScript ) {
        $URL = "https://dev.emberkom.com/emberkom/${Type}/raw/branch/master/${LivePSScript}.ps1"
        If ( !(IsURLValid -URL $URL) ) { LogMsg "The specified script does not exist: ${LivePSScript}" ; Exit }
    }
    If ( $Path ) { If ( !(Test-Path $Path) ) { LogMsg "The specified script does not exist: ""${Path}""" ; Exit } }
    If ( ($HaltIfRunning -ne $null ) -and ($ForceClose) -and ( !(IsAdmin) ) ) { LogMsg "Cannot close dependent apps because this task does not have administrative privileges" ; Exit }
    If ( $HaltIfRunning ) {
        $Halt = $false
        LogMsg "Checking for running instances of the following dependent apps:"
        ForEach ( $name in $HaltIfRunning) {
            $RunningInstances = Get-Process | Where { $_.Name -like "${name}" }
            If ( $RunningInstances ) {
                If ( $ForceClose -eq $true ) {
                    Try { $name | Stop-Process -Force ; LogMsg "    ""${name}"" (force closed)" }
                    Catch { LogErr $_.Exception.Message ; Exit }
                }
                Else { $Halt = $true ; LogMsg "    ""${name}"" (running)" }
            }
            Else { LogMsg "    ""${name}"" (not running)" }
        }
        If ( $Halt -eq $true ) { LogMsg "Dependent apps are currently in use and are preventing the specified script from running" ; Exit }
    }
    switch ($PSCmdlet.ParameterSetName) {
        'live-ps' {
            LogMsg "Retrieving : ${LivePSScript}.ps1"
            Try { $Script = (New-Object Net.WebClient).DownloadString($URL) }
            Catch { LogErr $_.Exception.Message ; Exit }
            Try { $ScriptBlock = [Scriptblock]::Create($Script) }
            Catch { LogErr $_.Exception.Message ; Exit }
            LogMsg "Executing: ${LivePSScript}.ps1 ${Arguments}"
            Try { Invoke-Command -ScriptBlock $ScriptBlock -ArgumentList $Arguments }
            Catch { LogErr $_.Exception.Message ; Exit }
        }
    
        'local' {
            LogMsg "Executing: ${Path} ${Arguments}"
            If ( $NoWait ) {
                Try {  Start-Process "${Path}" -ArgumentList "{$Arguments}" }
                Catch { LogErr $_.Exception.Message }
            }
            Else {
                LogMsg "    Waiting for script to finish..."
                Try { Start-Process "${Path}" -ArgumentList "{$Arguments}" -Wait }
                Catch { LogErr $_.Exception.Message }
                LogMsg "    Finished"
            }
        }
    }
    ## Write the log file output to the console
    If ( Test-Path $LogFile ) { Get-Content -Path $LogFile | Write-Output }
    Else { Write-Output "Log file not found at ""$LogFile""" }
}

## Return a Powershell version object from a string
Function Get-Version {
    param([Parameter(Mandatory=$true)][string]$Version)
    [int]$Sets = 4
    $VersionArray = $Version.Split('.')
    If ( $VersionArray.Count -le $Sets ) { $Sets = $VersionArray.Count }
    For ($i = 0; $i -le ($Sets - 1); $i++) {
        $Return = '{0}.{1}' -f $Return, $VersionArray[$i] }
    Return [version]$Return.Trim('.')
}

## Determines whether a URL is valid
Function IsURLValid {
    param([Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$URL)
    Try {
        $HTTPRequest = [System.Net.WebRequest]::Create($URL)
        $HTTPResponse = $HTTPRequest.GetResponse()
        $HTTPStatus = [int]$HTTPResponse.StatusCode
        $HTTPResponse.Close()
    }
    Catch { }
    If ($HTTPStatus -ne 404) { Return $true }
    Else { Return $false }
}

## Downloads a file from a URL
Function Download-File {
    param(
        [Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$URL,
        [Parameter(Mandatory=$false,ValueFromPipeline=$false)][string]$File
    )
    If ( !($File) ) { $File = '{0}{1}' -f (GetTempPath), (Split-Path $URL -Leaf) }
    If ( IsURLValid $URL ) { 
        If ( Test-Path $File ) {
            LogMsg "Deleting existing file: ""${File}"""
            Try { Remove-Item $File -Force }
            Catch { LogErr $_.Exception.Message }
        }
        LogMsg "Downloading ""${URL}"" to ""${File}"""
        Try { (New-Object System.Net.WebClient).DownloadFile($URL,$File) }
        Catch { LogErr $_.Exception.Message }
        If ( Test-Path "${File}" ) { Return "${File}" }
        Else { LogMsg "Downloaded file does not exist at ""${File}""" ; Return $false }
    }
    Else { LogMsg "URL is not valid or file cannot be reached: ${URL}" }
}

## Install a program from a provided path
Function Install-Program {
    param(
        [Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$Path,
        [Parameter(Mandatory=$false)][string]$Arguments = '',
        [Parameter(Mandatory=$false)][switch]$Delete = $false
    )
    If ( Test-Path "${Path}" ) {
        LogMsg "Running installer: ""${Path}"" ${Arguments}"
        Try {
            If ( $Arguments -eq '' ) { Start-Process "${Path}" -Wait }
            Else { Start-Process "${Path}" -ArgumentList "${Arguments}" -Wait }
        }
        Catch { LogErr $_.Exception.Message }
        LogMsg "Installer finished"
        If ( $Delete ) {
            LogMsg "Deleting installer: ""${Path}"""
            Try { Remove-Item -Path "${Path}" -Force }
            Catch { LogErr $_.Exception.Message }
        }
    }
    Else { LogMsg "The specified file could not be found: ""${Path}""" }
}

## Compare current Windows version with a supplied version
## The value supplied must be a string and must include at least 1 decimal
Function IsWindowsVersion {
    param(
        [Parameter(Mandatory=$true,ParameterSetName='gt')][string]$gt,
        [Parameter(Mandatory=$true,ParameterSetName='ge')][string]$ge,
        [Parameter(Mandatory=$true,ParameterSetName='lt')][string]$lt,
        [Parameter(Mandatory=$true,ParameterSetName='le')][string]$le,
        [Parameter(Mandatory=$true,ParameterSetName='eq')][string]$eq
    )
    [version]$WindowsVersion = [System.Environment]::OSVersion.Version
    switch ($PSCmdlet.ParameterSetName) {
        'gt' { If ( $WindowsVersion -gt (Get-Version $gt) ) { Return $true } Else { Return $false } }
        'ge' { If ( $WindowsVersion -ge (Get-Version $ge) ) { Return $true } Else { Return $false } }
        'lt' { If ( $WindowsVersion -lt (Get-Version $lt) ) { Return $true } Else { Return $false } }
        'le' { If ( $WindowsVersion -le (Get-Version $le) ) { Return $true } Else { Return $false } }
        'eq' { If ( $WindowsVersion -eq (Get-Version $eq) ) { Return $true } Else { Return $false } }
    }
}

## Compare current Windows build with a supplied version
## The value supplied must be an int
Function IsWindowsBuild {
    param(
        [Parameter(Mandatory=$true,ParameterSetName='gt')][int]$gt,
        [Parameter(Mandatory=$true,ParameterSetName='ge')][int]$ge,
        [Parameter(Mandatory=$true,ParameterSetName='lt')][int]$lt,
        [Parameter(Mandatory=$true,ParameterSetName='le')][int]$le,
        [Parameter(Mandatory=$true,ParameterSetName='eq')][int]$eq
    )
    [int]$WindowsBuild = [System.Environment]::OSVersion.Version.Build
    switch ($PSCmdlet.ParameterSetName) {
        'gt' { If ( $WindowsBuild -gt $gt ) { Return $true } Else { Return $false } }
        'ge' { If ( $WindowsBuild -ge $ge ) { Return $true } Else { Return $false } }
        'lt' { If ( $WindowsBuild -lt $lt ) { Return $true } Else { Return $false } }
        'le' { If ( $WindowsBuild -le $le ) { Return $true } Else { Return $false } }
        'eq' { If ( $WindowsBuild -eq $eq ) { Return $true } Else { Return $false } }
    }
}

## Get the path to the TEMP folder (context dependent)
Function GetTempPath { Return [System.IO.Path]::GetTempPath() }

## Determine if the system is 64-bit or not
Function Is64bit {
    switch ( $(Get-CimInstance -ClassName Win32_OperatingSystem -Property OSArchitecture | Select-Object -ExpandProperty OSArchitecture) )
    { '64-bit' { Return $true } '32-bit' { Return $false } }
}

## Determine if the Powershell process is 64-bit or not
Function Is64bitShell { If ( [System.Environment]::Is64BitProcess ) { Return $true } Else { Return $false } }

## Determine if a user is in a built-in role or specified group
Function IsMemberOf {
    param(
        [Parameter(Mandatory=$false)]
        [switch]$Builtin=$false,
        [Parameter(Mandatory=$true,ValueFromPipeline=$true)]
        [string]$Group
    )
    If ( $Builtin ) {
        Switch ( $Group ) {
            ("Administrator" -or "Administrators")
                { $Group = [System.Security.Principal.WindowsBuiltInRole]::Administrator ; Break }
            ("Backup Operator" -or "Backup Operators" -or "BackupOperator" -or "BackupOperators")
                { $Group = [System.Security.Principal.WindowsBuiltInRole]::BackupOperator ; Break }
            ("System Operator" -or "System Operators" -or "SystemOperator" -or "SystemOperators")
                { $Group = [System.Security.Principal.WindowsBuiltInRole]::SystemOperator ; Break }
            ("Account Operator" -or "Account Operators" -or "AccountOperator" -or "AccountOperators")
                { $Group = [System.Security.Principal.WindowsBuiltInRole]::AccountOperator ; Break }
            ("Print Operator" -or "Print Operators" -or "PrintOperator" -or "PrintOperators")
                { $Group = [System.Security.Principal.WindowsBuiltInRole]::PrintOperator ; Break }
            ("Replicator" -or "Replicators")
                { $Group = [System.Security.Principal.WindowsBuiltInRole]::Replicator ; Break }
            ("Power User" -or "Power Users" -or "PowerUser" -or "PowerUsers")
                { $Group = [System.Security.Principal.WindowsBuiltInRole]::PowerUser ; Break }
            ("User" -or "Users")
                { $Group = [System.Security.Principal.WindowsBuiltInRole]::User ; Break }
            ("Guest" -or "Guests")
                { $Group = [System.Security.Principal.WindowsBuiltInRole]::Guest ; Break }
            default { ; Break }
        }
    }
    Return ([Security.Principal.WindowsPrincipal][System.Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole($Group)
}

## Start, stop, restart, or delete a list of services
Function Control-Service
{
    param(
        [Parameter(Mandatory=$true,ParameterSetName='start')]
        [switch]$Start,
        [Parameter(Mandatory=$true,ParameterSetName='stop')]
        [switch]$Stop,
        [Parameter(Mandatory=$true,ParameterSetName='restart')]
        [switch]$Restart,
        [Parameter(Mandatory=$true,ParameterSetName='delete')]
        [switch]$Delete,
        [Parameter(Mandatory=$true,ValueFromPipeline=$true,ParameterSetName='start')]
        [Parameter(Mandatory=$true,ValueFromPipeline=$true,ParameterSetName='stop')]
        [Parameter(Mandatory=$true,ValueFromPipeline=$true,ParameterSetName='restart')]
        [Parameter(Mandatory=$true,ValueFromPipeline=$true,ParameterSetName='delete')]
        [string[]]$Name,
        [Parameter(Mandatory=$false,ParameterSetName='start')]
        [Parameter(Mandatory=$false,ParameterSetName='stop')]
        [Parameter(Mandatory=$false,ParameterSetName='restart')]
        [Parameter(Mandatory=$false,ParameterSetName='delete')]
        [switch]$Match=$false
    )
    switch ($PSCmdlet.ParameterSetName) {
        'start' {
            $statuscondition = 'Running'
            $verb = 'start'
            $verbing = 'Starting'
            $verbed = $statuscondition.ToLower()
        }
        'stop' {
            $statuscondition = 'Stopped'
            $verb = 'stop'
            $verbing = 'Stopping'
            $verbed = $statuscondition.ToLower()
        }
        'restart' {
            $LaunchCommand = $MyInvocation.MyCommand
            $ArgString = $MyInvocation.Line
            $StopCmd = $ArgString -replace ' -Restart ', ' -Stop '
            $StartCmd = $ArgString -replace ' -Restart ', ' -Start '
            Invoke-Expression $StopCmd
            #Start-Sleep -Seconds 10
            Invoke-Expression $StartCmd
            Exit
        }
        'delete' {
            ## Delete the service
        }
    }
    ForEach ( $item in $Name ) {
        $service = Get-Service -Name $item -ErrorAction SilentlyContinue
        If ( !($service) ) {
            LogMsg "Cannot find the service '${item}'"
            If ( $Match ) {
                LogMsg "Attempting to match '${item}' to service display names"
                ForEach ( $svc in ((Get-Service | Where { $_.DisplayName -match $item }).Name) ) {
                    Switch ( $verb) {
                        'start' { Control-Service -Start -Name $svc }
                        'stop' { Control-Service -Stop -Name $svc }
                    }
                }
            }
        }
        Else {
            $name = $service.Name
            $fullname = $service.DisplayName
            If ( ($fullname -eq $null) -or ($fullname -eq '') -or ($fullname -eq $name) ) {
                $displayname = "'${name}'"
            }
            Else {
                $displayname = """${fullname}"" (${name})"
            }
            If ( $service.Status -ne $statuscondition ) {
                LogMsg "${verbing} ${displayname}"
                Switch ( $verb) {
                    'start' {
                        Try { Start-Service -Name $name }
                        Catch { LogErr $_.Exception.Message }
                    }
                    'stop' {
                        Try { Stop-Service -Name $name -Force }
                        Catch { LogErr $_.Exception.Message }
                    }
                }
            }
        }
    }
}

## Stop a process
Function End-Process
{
    param(
        [Parameter(Mandatory=$true,ValueFromPipeline=$true)][string[]]$Name,
        [Parameter(Mandatory=$false)][switch]$Match=$false,
        [Parameter(Mandatory=$false)][switch]$Force=$false
    )
    ForEach ( $item in $Name ) {
        $process = Get-Process -Name $item -ErrorAction SilentlyContinue
        If ( !($process) ) {
            LogMsg "Cannot find the process '${item}'"
            If ( $Match ) {
                LogMsg "Attempting to match '${item}' to all running process names"
                ForEach ( $proc in ((Get-Process | Where { $_.Name -match $item }).Name) ) {
                    If ( $Force ) { End-Process -Name $proc -Force } Else { End-Process -Name $proc }
                }
            }
        }
        Else {
            $name = $process.Name
            If ( $Force ) {
                LogMsg "Forcefully stopping '${name}' process"
                Stop-Process $process -Force -ErrorAction SilentlyContinue
            }
            Else {
                LogMsg "Attempting to gracefully close '${name}' process"
                $process.CloseMainWindow() | Out-Null
            }
        }
    }
}

Function Create-Shortcut {
    param(
        [Parameter(Mandatory=$true)][string]$Path,
        [Parameter(Mandatory=$true)][string]$TargetPath,
        [Parameter(Mandatory=$false)][string]$Arguments,
        [Parameter(Mandatory=$false)][string]$Description,
        [Parameter(Mandatory=$false)][string]$Icon = '',
        [Parameter(Mandatory=$false)][string]$WorkingDirectory = ''
    )
    If ( Test-Path $TargetPath ) {
        If ( Test-Path $Path ) {
            LogMsg "Deleting existing shortcut at ""${Path}"""
            Try { Remove-Item $Path -Force -ErrorAction SilentlyContinue }
            Catch { LogErr $_.Exception.Message }
        }
        If ( $WorkingDirectory -eq '' ) { $WorkingDirectory = Split-Path $TargetPath -Parent }
        If ( $Icon -eq '' ) { $Icon = "${TargetPath}, 0" }
        $WshShell = New-Object -ComObject WScript.Shell
        $Shortcut = $WshShell.CreateShortcut($Path)
        $Shortcut.Arguments = $Arguments
        $Shortcut.Description = $Description
        $Shortcut.IconLocation = $Icon
        $Shortcut.WorkingDirectory = $WorkingDirectory
        $Shortcut.TargetPath = $TargetPath
        LogMsg "Creating shortcut to ""${TargetPath}"" at ""${Path}"""
        Try { $Shortcut.Save() }
        Catch { LogErr $_.Exception.Message }
    }
    Else { LogMsg "Cannot create shortcut because the target path does not exist" }
}

# Function to enable or disable a specified log
function Toggle-Log {
    param (
        [Parameter(Mandatory = $true)][string]$Name,
        [Parameter(Mandatory = $true, ParameterSetName = 'Enable')][switch]$Enable,
        [Parameter(Mandatory = $true, ParameterSetName = 'Disable')][switch]$Disable
    )
    Try {
    $log = New-Object System.Diagnostics.Eventing.Reader.EventLogConfiguration $Name 
    If ( $Enable ) { LogMsg "Enabing ${Name} event log" ; $log.IsEnabled = $true }
    If ( $Disable ) { LogMsg "Disabing ${Name} event log" ; $log.IsEnabled = $false }
    $log.SaveChanges()
    }
    Catch { LogMsg $_.Exception.Message }
}

Setup-MSPDirectories
Setup-LogFile